@edgebound/bigcommerce 0.0.1

package/dist/orders.js

@@ -0,0 +1,608 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/bigcommerce-entities/orders/index.ts
+var orders_exports = {};
+__export(orders_exports, {
+  OrderSchema: () => OrderSchema,
+  findOrders: () => findOrders,
+  getAllOrderProducts: () => getAllOrderProducts,
+  getAllOrdersBy: () => getAllOrdersBy,
+  getOrder: () => getOrder
+});
+module.exports = __toCommonJS(orders_exports);
+
+// src/bigcommerce-entities/orders/find-orders.ts
+var import_effect8 = require("effect");
+var z6 = __toESM(require("zod"));
+
+// src/constants.ts
+var import_effect = require("effect");
+var DEFAULT_TIMEOUT_MS = 3e4;
+var API_BASE_URLS = {
+  B2B: "https://api-b2b.bigcommerce.com/api",
+  REGULAR: "https://api.bigcommerce.com/stores"
+};
+var GET_ORDER_BATCH_SIZE = 250;
+var DEFAULT_RETRY_TIMES = 2;
+var DEFAULT_RETRY_WAIT = 200;
+var DEFAULT_RETRY_SCHEDULE = import_effect.Schedule.exponential(import_effect.Duration.millis(DEFAULT_RETRY_WAIT));
+var RETRY_POLICY_WITH_BACKOFF = import_effect.Schedule.exponential(
+  import_effect.Duration.millis(DEFAULT_RETRY_WAIT),
+  2
+).pipe(import_effect.Schedule.intersect(import_effect.Schedule.recurs(DEFAULT_RETRY_TIMES)));
+
+// src/core/bigcommerce.error.ts
+var import_effect2 = require("effect");
+var BigCommerceUnprocessableEntityError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceUnprocessableEntityError"
+) {
+};
+var BigCommerceUnauthorizedError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceUnauthorizedError"
+) {
+};
+var BigCommerceForbiddenError = class extends import_effect2.Data.TaggedError("BigCommerceForbiddenError") {
+};
+var BigCommerceNotFoundError = class extends import_effect2.Data.TaggedError("BigCommerceNotFoundError") {
+};
+var BigCommerceConflictError = class extends import_effect2.Data.TaggedError("BigCommerceConflictError") {
+};
+var BigCommerceConnectionError = class extends import_effect2.Data.TaggedError("BigCommerceConnectionError") {
+};
+var BigCommerceUnknownError = class extends import_effect2.Data.TaggedError("BigCommerceUnknownError") {
+};
+var BigCommerceInvalidResponseError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceInvalidResponseError"
+) {
+};
+var BigCommerceInvalidRequestError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceInvalidRequestError"
+) {
+};
+var BigCommerceParseResponseError = class extends import_effect2.Data.TaggedError(
+  "BigCommerceParseResponseError"
+) {
+};
+
+// src/core/bigcommerce.fetcher.ts
+var import_effect3 = require("effect");
+var BigCommerceFetcher = class extends import_effect3.Context.Tag("BigCommerceFetcher")() {
+};
+
+// src/core/bigcommerce.fetcher.live.ts
+var import_effect5 = require("effect");
+
+// src/core/config.ts
+var import_effect4 = require("effect");
+var NoBigCommerceConfigError = class extends import_effect4.Data.TaggedError("NoBigCommerceConfigError") {
+};
+var BigCommerceConfig = class extends import_effect4.Context.Tag("BigCommerceConfig")() {
+};
+var getBigCommerceConfig = (key) => {
+  return import_effect4.Config.nested(import_effect4.Config.string(key), "BIGCOMMERCE").pipe(
+    import_effect4.Effect.mapError(() => new NoBigCommerceConfigError({ key }))
+  );
+};
+var getBigCommerceTimeout = () => {
+  return import_effect4.Config.nested(import_effect4.Config.number("TIMEOUT"), "BIGCOMMERCE").pipe(
+    import_effect4.Effect.mapError(() => new NoBigCommerceConfigError({ key: "TIMEOUT" })),
+    // Default to 30 seconds if not configured
+    import_effect4.Effect.orElse(() => import_effect4.Effect.succeed(DEFAULT_TIMEOUT_MS))
+  );
+};
+var BigCommerceConfigLive = import_effect4.Layer.effect(
+  BigCommerceConfig,
+  import_effect4.Effect.gen(function* () {
+    const [storeHash, clientId, clientSecret, accessToken, timeout] = yield* import_effect4.Effect.all([
+      getBigCommerceConfig("STORE_HASH"),
+      getBigCommerceConfig("CLIENT_ID"),
+      getBigCommerceConfig("CLIENT_SECRET"),
+      getBigCommerceConfig("ACCESS_TOKEN"),
+      getBigCommerceTimeout()
+    ]);
+    return {
+      getStoreHash: import_effect4.Effect.succeed(storeHash),
+      getClientId: import_effect4.Effect.succeed(clientId),
+      getClientSecret: import_effect4.Effect.succeed(clientSecret),
+      getAccessToken: import_effect4.Effect.succeed(accessToken),
+      getTimeout: import_effect4.Effect.succeed(timeout)
+    };
+  })
+);
+var BigCommerceConfigTest = import_effect4.Layer.succeed(BigCommerceConfig, {
+  getAccessToken: import_effect4.Effect.succeed("test"),
+  getClientId: import_effect4.Effect.succeed("test"),
+  getClientSecret: import_effect4.Effect.succeed("test"),
+  getStoreHash: import_effect4.Effect.succeed("test"),
+  getTimeout: import_effect4.Effect.succeed(DEFAULT_TIMEOUT_MS)
+});
+
+// src/core/bigcommerce.fetcher.live.ts
+var BigCommerceStatusCodes = {
+  UNAUTHORIZED: 401,
+  CONFLICT: 409,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  INVALID_REQUEST: 400
+};
+var BigCommerceFetcherLive = import_effect5.Layer.effect(
+  BigCommerceFetcher,
+  import_effect5.Effect.gen(function* () {
+    const config = yield* BigCommerceConfig;
+    const storeHash = yield* config.getStoreHash;
+    const accessToken = yield* config.getAccessToken;
+    const timeout = yield* config.getTimeout;
+    return {
+      fetch: (params) => {
+        const base = getBase(params);
+        const headers = {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          "x-auth-token": accessToken
+        };
+        if (params.isB2B) {
+          headers["x-store-hash"] = storeHash;
+        }
+        const url = applyParams(base.replace("[storeHash]", storeHash), params.query);
+        return import_effect5.Effect.tryPromise({
+          try: () => fetch(url, {
+            headers,
+            signal: AbortSignal.timeout(timeout),
+            method: params.method,
+            ...params.body && { body: JSON.stringify(params.body) }
+          }),
+          catch: (error) => {
+            if (error instanceof Error && error.name === "TimeoutError") {
+              return new BigCommerceConnectionError({
+                message: `Request timeout after ${timeout}ms`,
+                type: "timeout"
+              });
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+              return new BigCommerceConnectionError({
+                message: `Request timeout after ${timeout}ms`,
+                type: "timeout"
+              });
+            }
+            return new BigCommerceUnknownError({ cause: error });
+          }
+        }).pipe(
+          import_effect5.Effect.tapError(
+            (error) => import_effect5.Effect.logError("Failed to fetch from BigCommerce API", error.cause)
+          ),
+          import_effect5.Effect.flatMap((response) => transformResponse(response, params.resultSchema))
+        );
+      }
+    };
+  })
+);
+var applyParams = (url, params) => {
+  const base = new URL(url);
+  if (!params) {
+    return base;
+  }
+  for (const [key, value] of Object.entries(params)) {
+    base.searchParams.append(key, `${value}`);
+  }
+  return base;
+};
+var getBase = ({
+  isB2B,
+  path,
+  version
+}) => {
+  if (isB2B) {
+    return `${API_BASE_URLS.B2B}/${version}/io/${path}`;
+  }
+  return `${API_BASE_URLS.REGULAR}/[storeHash]/${version}/${path}`;
+};
+function processSuccessResponse(response, schema) {
+  return import_effect5.Effect.tryPromise({
+    try: () => response.json(),
+    catch: (error) => new BigCommerceInvalidResponseError({ cause: error })
+  }).pipe(
+    import_effect5.Effect.tapError(
+      (error) => import_effect5.Effect.logError("Error parsing response from BigCommerce API", error.cause)
+    ),
+    import_effect5.Effect.tryMap({
+      try: (json) => schema.parse(json),
+      catch: (error) => new BigCommerceParseResponseError({ error })
+    })
+  );
+}
+var processErrorResponse = (response) => {
+  const code = response.status;
+  return import_effect5.Effect.tryPromise({
+    try: () => response.json(),
+    catch: (error) => new BigCommerceInvalidResponseError({ cause: error })
+  }).pipe(
+    import_effect5.Effect.tapError((error) => import_effect5.Effect.logError("Error parsing error response", error.cause)),
+    import_effect5.Effect.flatMap(
+      (errorDetails) => import_effect5.Effect.fail(
+        import_effect5.Match.value(code).pipe(
+          import_effect5.Match.when(
+            BigCommerceStatusCodes.INVALID_REQUEST,
+            () => new BigCommerceInvalidRequestError({ errorDetails })
+          ),
+          import_effect5.Match.when(BigCommerceStatusCodes.UNAUTHORIZED, () => new BigCommerceUnauthorizedError()),
+          import_effect5.Match.when(BigCommerceStatusCodes.FORBIDDEN, () => new BigCommerceForbiddenError()),
+          import_effect5.Match.when(BigCommerceStatusCodes.NOT_FOUND, () => new BigCommerceNotFoundError()),
+          import_effect5.Match.when(
+            BigCommerceStatusCodes.CONFLICT,
+            () => new BigCommerceConflictError({ details: errorDetails })
+          ),
+          import_effect5.Match.when(
+            BigCommerceStatusCodes.UNPROCESSABLE_ENTITY,
+            () => new BigCommerceUnprocessableEntityError({ errorDetails })
+          ),
+          import_effect5.Match.when(
+            (code2) => code2 >= 500,
+            () => new BigCommerceConnectionError({
+              message: `Server error: ${code}`,
+              type: code === BigCommerceStatusCodes.INTERNAL_SERVER_ERROR ? "internalError" : code === BigCommerceStatusCodes.BAD_GATEWAY || code === BigCommerceStatusCodes.GATEWAY_TIMEOUT ? "timeout" : "internalError"
+            })
+          ),
+          import_effect5.Match.orElse(() => new BigCommerceUnknownError({ cause: errorDetails }))
+        )
+      )
+    )
+  );
+};
+var transformResponse = (response, schema) => {
+  if (response.ok) {
+    return processSuccessResponse(response, schema);
+  }
+  return processErrorResponse(response);
+};
+
+// src/validation/index.ts
+var import_effect7 = require("effect");
+
+// src/validation/validation.error.ts
+var import_effect6 = require("effect");
+var InputValidationError = class extends import_effect6.Data.TaggedError("InputValidationError") {
+};
+
+// src/validation/index.ts
+var validateInput = (schema, data) => {
+  return import_effect7.Effect.try({
+    try: () => schema.parse(data),
+    catch: (error) => new InputValidationError({ input: data, error })
+  });
+};
+
+// src/bigcommerce-entities/orders/schemas/order.schema.ts
+var z4 = __toESM(require("zod"));
+
+// src/bigcommerce-entities/addresses/schemas/address.schema.ts
+var z2 = __toESM(require("zod"));
+
+// src/bigcommerce-entities/addresses/schemas/form-field.schema.ts
+var z = __toESM(require("zod"));
+var AddressFormFieldSchema = z.object({
+  name: z.string(),
+  value: z.string()
+});
+
+// src/bigcommerce-entities/addresses/schemas/address.schema.ts
+var AddressSchema = z2.object({
+  first_name: z2.string(),
+  last_name: z2.string(),
+  company: z2.string(),
+  street_1: z2.string(),
+  street_2: z2.string(),
+  city: z2.string(),
+  state: z2.string(),
+  zip: z2.string(),
+  country: z2.string(),
+  country_iso2: z2.string(),
+  phone: z2.string(),
+  email: z2.string(),
+  form_fields: z2.array(AddressFormFieldSchema)
+});
+
+// src/bigcommerce-entities/orders/schemas/status.schema.ts
+var z3 = __toESM(require("zod"));
+var OrderStatusNameEnumSchema = z3.enum([
+  "Incomplete",
+  "Pending",
+  "Shipped",
+  "Partially Shipped",
+  "Refunded",
+  "Cancelled",
+  "Declined",
+  "Awaiting Payment",
+  "Awaiting Pickup",
+  "Awaiting Shipment",
+  "Completed",
+  "Awaiting Fulfillment",
+  "Manual Verification Required",
+  "Disputed",
+  "Partially Refunded"
+]);
+var OrderStatusEnum = /* @__PURE__ */ ((OrderStatusEnum2) => {
+  OrderStatusEnum2[OrderStatusEnum2["Incomplete"] = 0] = "Incomplete";
+  OrderStatusEnum2[OrderStatusEnum2["Pending"] = 1] = "Pending";
+  OrderStatusEnum2[OrderStatusEnum2["Shipped"] = 2] = "Shipped";
+  OrderStatusEnum2[OrderStatusEnum2["PartiallyShipped"] = 3] = "PartiallyShipped";
+  OrderStatusEnum2[OrderStatusEnum2["Refunded"] = 4] = "Refunded";
+  OrderStatusEnum2[OrderStatusEnum2["Cancelled"] = 5] = "Cancelled";
+  OrderStatusEnum2[OrderStatusEnum2["Declined"] = 6] = "Declined";
+  OrderStatusEnum2[OrderStatusEnum2["AwaitingPayment"] = 7] = "AwaitingPayment";
+  OrderStatusEnum2[OrderStatusEnum2["AwaitingPickup"] = 8] = "AwaitingPickup";
+  OrderStatusEnum2[OrderStatusEnum2["AwaitingShipment"] = 9] = "AwaitingShipment";
+  OrderStatusEnum2[OrderStatusEnum2["Completed"] = 10] = "Completed";
+  OrderStatusEnum2[OrderStatusEnum2["AwaitingFulfillment"] = 11] = "AwaitingFulfillment";
+  OrderStatusEnum2[OrderStatusEnum2["ManualVerificationRequired"] = 12] = "ManualVerificationRequired";
+  OrderStatusEnum2[OrderStatusEnum2["Disputed"] = 13] = "Disputed";
+  OrderStatusEnum2[OrderStatusEnum2["PartiallyRefunded"] = 14] = "PartiallyRefunded";
+  return OrderStatusEnum2;
+})(OrderStatusEnum || {});
+var OrderStatusSchema = z3.enum(OrderStatusEnum);
+
+// src/bigcommerce-entities/orders/schemas/order.schema.ts
+var OrderSchema = z4.object({
+  id: z4.number(),
+  customer_id: z4.number(),
+  date_created: z4.string(),
+  is_tax_inclusive_pricing: z4.boolean(),
+  date_modified: z4.string(),
+  date_shipped: z4.string(),
+  status_id: z4.number(),
+  status: OrderStatusNameEnumSchema,
+  subtotal_ex_tax: z4.string(),
+  subtotal_inc_tax: z4.string(),
+  subtotal_tax: z4.string(),
+  base_shipping_cost: z4.string(),
+  shipping_cost_ex_tax: z4.string(),
+  shipping_cost_inc_tax: z4.string(),
+  shipping_cost_tax: z4.string(),
+  shipping_cost_tax_class_id: z4.number(),
+  base_handling_cost: z4.string(),
+  handling_cost_ex_tax: z4.string(),
+  handling_cost_inc_tax: z4.string(),
+  handling_cost_tax: z4.string(),
+  handling_cost_tax_class_id: z4.number(),
+  base_wrapping_cost: z4.string(),
+  wrapping_cost_ex_tax: z4.string(),
+  wrapping_cost_inc_tax: z4.string(),
+  wrapping_cost_tax: z4.string(),
+  wrapping_cost_tax_class_id: z4.number(),
+  total_ex_tax: z4.string(),
+  total_inc_tax: z4.string(),
+  total_tax: z4.string(),
+  items_total: z4.number(),
+  items_shipped: z4.number(),
+  payment_method: z4.string(),
+  payment_provider_id: z4.string(),
+  payment_status: z4.string(),
+  refunded_amount: z4.string(),
+  order_is_digital: z4.boolean(),
+  store_credit_amount: z4.string(),
+  gift_certificate_amount: z4.string(),
+  ip_address: z4.string(),
+  ip_address_v6: z4.string(),
+  geoip_country: z4.string(),
+  geoip_country_iso2: z4.string(),
+  currency_id: z4.number(),
+  currency_code: z4.string(),
+  currency_exchange_rate: z4.string(),
+  default_currency_id: z4.number(),
+  default_currency_code: z4.string(),
+  staff_notes: z4.string(),
+  customer_message: z4.string(),
+  discount_amount: z4.string(),
+  coupon_discount: z4.string(),
+  shipping_address_count: z4.number(),
+  is_deleted: z4.boolean(),
+  ebay_order_id: z4.string(),
+  cart_id: z4.string(),
+  billing_address: AddressSchema,
+  is_email_opt_in: z4.boolean(),
+  order_source: z4.string(),
+  channel_id: z4.number(),
+  external_source: z4.string(),
+  external_id: z4.string().nullable(),
+  tax_provider_id: z4.string(),
+  customer_locale: z4.string(),
+  external_order_id: z4.string().nullable(),
+  store_default_currency_code: z4.string(),
+  store_default_to_transactional_exchange_rate: z4.string(),
+  custom_status: z4.string()
+});
+
+// src/bigcommerce-entities/orders/schemas/find-orders.criteria.ts
+var z5 = __toESM(require("zod"));
+var FindOrdersCriteriaSchema = z5.object({
+  customer_id: z5.string().optional(),
+  email: z5.string().optional(),
+  status_id: z5.number().optional(),
+  cart_id: z5.string().optional(),
+  payment_method: z5.string().optional(),
+  min_date_created: z5.iso.datetime({ offset: true }).optional(),
+  max_date_created: z5.iso.datetime({ offset: true }).optional(),
+  min_date_modified: z5.iso.datetime({ offset: true }).optional(),
+  max_date_modified: z5.iso.datetime({ offset: true }).optional(),
+  page: z5.number().min(1).optional(),
+  limit: z5.number().min(1).max(GET_ORDER_BATCH_SIZE).optional(),
+  // Allowed: id | customer_id | date_created | date_modified | status_id | channel_id | external_id;
+  sort: z5.string().optional(),
+  channel_id: z5.int().optional()
+});
+
+// src/bigcommerce-entities/orders/find-orders.ts
+var OrderArraySchema = z6.union([z6.array(OrderSchema), z6.literal(""), z6.literal(null)]);
+var findOrders = (criteria) => {
+  return import_effect8.Effect.gen(function* () {
+    const fetcher = yield* BigCommerceFetcher;
+    const validatedResponse = yield* validateInput(FindOrdersCriteriaSchema, criteria ?? {});
+    const query = {};
+    for (const [key, value] of Object.entries(validatedResponse)) {
+      if (value !== void 0) {
+        query[key] = `${value}`;
+      }
+    }
+    const orders = yield* fetcher.fetch({
+      query,
+      isB2B: false,
+      method: "GET",
+      path: "orders",
+      version: "v2",
+      resultSchema: OrderArraySchema
+    });
+    return orders || [];
+  });
+};
+var getAllOrdersBy = (criteria) => {
+  return import_effect8.Effect.gen(function* () {
+    const allOrders = [];
+    let page = 1;
+    let hasMoreOrders = true;
+    while (hasMoreOrders) {
+      const orders = yield* findOrders({
+        ...criteria,
+        page,
+        limit: GET_ORDER_BATCH_SIZE
+      });
+      if (orders.length === 0) {
+        hasMoreOrders = false;
+      } else {
+        allOrders.push(...orders);
+        page++;
+      }
+    }
+    return allOrders;
+  });
+};
+
+// src/bigcommerce-entities/orders/get-order.ts
+var import_effect9 = require("effect");
+var getOrder = (orderId) => {
+  return import_effect9.Effect.gen(function* () {
+    const fetcher = yield* BigCommerceFetcher;
+    return yield* fetcher.fetch({
+      isB2B: false,
+      method: "GET",
+      path: `orders/${orderId}`,
+      resultSchema: OrderSchema,
+      version: "v2"
+    });
+  });
+};
+
+// src/bigcommerce-entities/orders/get-products.ts
+var import_effect10 = require("effect");
+var z8 = __toESM(require("zod"));
+
+// src/bigcommerce-entities/orders/schemas/order-product.schema.ts
+var z7 = __toESM(require("zod"));
+var OrderProductSchema = z7.object({
+  id: z7.int(),
+  order_id: z7.int(),
+  product_id: z7.int(),
+  variant_id: z7.int(),
+  order_address_id: z7.int(),
+  sku: z7.string(),
+  type: z7.enum(["physical", "digital"]),
+  base_price: z7.coerce.number(),
+  price_ex_tax: z7.coerce.number(),
+  price_inc_tax: z7.coerce.number(),
+  price_tax: z7.coerce.number(),
+  base_total: z7.coerce.number(),
+  total_ex_tax: z7.coerce.number(),
+  total_inc_tax: z7.coerce.number(),
+  total_tax: z7.coerce.number(),
+  weight: z7.coerce.number(),
+  width: z7.coerce.number(),
+  height: z7.coerce.number(),
+  depth: z7.coerce.number(),
+  quantity: z7.int(),
+  base_cost_price: z7.coerce.number(),
+  cost_price_inc_tax: z7.coerce.number(),
+  cost_price_ex_tax: z7.coerce.number(),
+  cost_price_tax: z7.coerce.number()
+});
+
+// src/bigcommerce-entities/orders/get-products.ts
+var getOrderProducts = ({
+  orderId,
+  limit = GET_ORDER_BATCH_SIZE,
+  page
+}) => {
+  return import_effect10.Effect.gen(function* () {
+    const fetcher = yield* BigCommerceFetcher;
+    return yield* fetcher.fetch({
+      method: "GET",
+      path: `orders/${orderId}/products`,
+      isB2B: false,
+      version: "v2",
+      resultSchema: z8.union([z8.array(OrderProductSchema), z8.literal(""), z8.literal(null)]),
+      query: {
+        limit: `${limit}`,
+        page: `${page}`
+      }
+    });
+  }).pipe(import_effect10.Effect.map((arr) => arr || []));
+};
+var getAllOrderProducts = (orderId) => {
+  return import_effect10.Effect.gen(function* () {
+    const all = [];
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const result = yield* getOrderProducts({
+        orderId,
+        page,
+        limit: GET_ORDER_BATCH_SIZE
+      });
+      if (result.length) {
+        all.push(...result);
+        page++;
+      } else {
+        hasMore = false;
+      }
+    }
+    return all;
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OrderSchema,
+  findOrders,
+  getAllOrderProducts,
+  getAllOrdersBy,
+  getOrder
+});
+//# sourceMappingURL=orders.js.map