@reactionary/acp 0.0.0-stage → 0.10.31

package/lib/reactionary-acp-server.js

@@ -0,0 +1,815 @@
+import {
+  createInitialRequestContext,
+  MemoryCache,
+  SessionSchema
+} from "@reactionary/core";
+import {
+  ReactionaryFeedGenerator,
+  acpProductFeedTransformer
+} from "@reactionary/feeds";
+import {
+  ACPCheckoutSessionStateSchema,
+  ACPCompleteCheckoutSessionRequestSchema,
+  ACPCreateCheckoutSessionRequestSchema,
+  ACPUpdateCheckoutSessionRequestSchema
+} from "./acp-schemas.js";
+const ACP_SESSION_ID_HEADER = "acp-session-id";
+const SESSION_CACHE_KEY_PREFIX = "reactionary:acp:session";
+const CHECKOUT_SESSION_CACHE_KEY_PREFIX = "reactionary:acp:checkout-session";
+class ReactionaryACPServer {
+  constructor(clientFactory, options = {}) {
+    this.clientFactory = clientFactory;
+    this.options = options;
+    this.sessionStore = new ReactionaryACPSessionStore(
+      this.options.sessionCache ?? new MemoryCache(),
+      this.options.sessionTtlSeconds ?? 60 * 60 * 24
+    );
+    this.checkoutSessionStore = new ReactionaryACPCheckoutSessionStore(
+      this.options.sessionCache ?? new MemoryCache(),
+      this.options.checkoutSessionTtlSeconds ?? 60 * 60 * 24
+    );
+    assertACPClient(this.clientFactory(createInitialRequestContext()));
+  }
+  clientFactory;
+  options;
+  sessionStore;
+  checkoutSessionStore;
+  async fetch(request) {
+    const sessionId = getOrCreateSessionId(request);
+    const requestContext = await this.createRequestContext(sessionId);
+    const requestedFeed = this.getRequestedProductFeed(request);
+    if (requestedFeed) {
+      requestContext.languageContext = requestedFeed.feed.languageContext;
+    }
+    const client = this.clientFactory(requestContext);
+    assertACPClient(client);
+    const response = await this.handleRequest(request, client, requestContext).catch((error) => toACPErrorResponse(error));
+    await this.sessionStore.put(sessionId, requestContext.session);
+    response.headers.set(ACP_SESSION_ID_HEADER, sessionId);
+    return response;
+  }
+  getHandler() {
+    return {
+      fetch: (request) => this.fetch(request),
+      close: () => this.close()
+    };
+  }
+  toNodeHandler() {
+    return async (request, response) => {
+      const webResponse = await this.fetch(await toWebRequest(request));
+      await sendWebResponse(response, webResponse);
+    };
+  }
+  close() {
+    return Promise.resolve();
+  }
+  async createRequestContext(sessionId) {
+    const restoredSession = await this.sessionStore.get(sessionId);
+    const requestContext = createInitialRequestContext();
+    if (restoredSession) {
+      requestContext.session = restoredSession;
+    }
+    return requestContext;
+  }
+  async handleRequest(request, client, requestContext) {
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: {
+          allow: "GET, HEAD, OPTIONS, POST"
+        }
+      });
+    }
+    if (request.method === "GET" || request.method === "HEAD") {
+      const productFeedId = getProductFeedId(request, this.options.basePath);
+      if (productFeedId) {
+        const feed = this.getProductFeedDefinition(productFeedId);
+        if (!feed) {
+          return acpErrorResponse(404, {
+            type: "invalid_request",
+            code: "missing",
+            message: `Product feed not found: ${productFeedId}`
+          });
+        }
+        return this.getProductFeed(
+          request,
+          productFeedId,
+          feed,
+          client,
+          requestContext,
+          request.method === "HEAD"
+        );
+      }
+      const checkoutSessionId = getCheckoutSessionId(
+        request,
+        this.options.basePath
+      );
+      if (checkoutSessionId) {
+        return this.getCheckoutSession(
+          checkoutSessionId,
+          client,
+          request.method === "HEAD"
+        );
+      }
+      return jsonResponse(this.getReadinessDocument(), {
+        omitBody: request.method === "HEAD"
+      });
+    }
+    if (request.method === "POST") {
+      return this.handlePost(request, client, requestContext);
+    }
+    return jsonResponse({
+      error: {
+        code: "METHOD_NOT_ALLOWED",
+        message: `Unsupported method: ${request.method}`
+      }
+    }, {
+      status: 405,
+      headers: {
+        allow: "GET, HEAD, OPTIONS, POST"
+      }
+    });
+  }
+  getReadinessDocument() {
+    return {
+      name: this.options.name ?? "@reactionary/acp",
+      version: this.options.version ?? "0.0.1",
+      protocol: "acp",
+      status: "ready",
+      actions: [
+        "POST /checkout_sessions",
+        "POST /checkout_sessions/{checkout_session_id}",
+        "GET /checkout_sessions/{checkout_session_id}",
+        "POST /checkout_sessions/{checkout_session_id}/complete",
+        "POST /checkout_sessions/{checkout_session_id}/cancel",
+        "GET /product_feeds/{id}/products"
+      ]
+    };
+  }
+  async getProductFeed(request, feedId, feed, client, requestContext, omitBody) {
+    const format = new URL(request.url).searchParams.get("format") ?? "json";
+    if (format !== "json" && format !== "jsonl") {
+      return acpErrorResponse(400, {
+        type: "invalid_request",
+        code: "invalid",
+        message: `Unsupported product feed format: ${format}`,
+        param: "$.format"
+      });
+    }
+    const generator = new ReactionaryFeedGenerator(client, {
+      defaultFulfillmentCenterKeys: this.options.productFeed?.defaultFulfillmentCenterKeys,
+      productConcurrency: this.options.productFeed?.productConcurrency
+    });
+    const output = acpProductFeedTransformer.transform(
+      generator.products(feed, requestContext),
+      {
+        feedId,
+        feed,
+        options: { format }
+      }
+    );
+    const extension = format === "jsonl" ? "jsonl" : "json";
+    return new Response(
+      omitBody ? null : createFeedStream(output),
+      {
+        headers: {
+          "content-type": format === "jsonl" ? "application/x-ndjson; charset=utf-8" : "application/json; charset=utf-8",
+          "content-disposition": `attachment; filename="${feedId}.products.${extension}"`
+        }
+      }
+    );
+  }
+  getRequestedProductFeed(request) {
+    const id = getProductFeedId(request, this.options.basePath);
+    const feed = id ? this.getProductFeedDefinition(id) : void 0;
+    return id && feed ? { id, feed } : void 0;
+  }
+  getProductFeedDefinition(feedId) {
+    return this.options.productFeed?.feeds[feedId];
+  }
+  async handlePost(request, client, requestContext) {
+    const checkoutSessionId = getCheckoutSessionId(
+      request,
+      this.options.basePath
+    );
+    if (!checkoutSessionId) {
+      return this.createCheckoutSession(
+        await parseJsonBody(request, ACPCreateCheckoutSessionRequestSchema),
+        client,
+        requestContext
+      );
+    }
+    if (isCheckoutSessionCompleteRequest(request, this.options.basePath)) {
+      return this.completeCheckoutSession(
+        checkoutSessionId,
+        await parseJsonBody(request, ACPCompleteCheckoutSessionRequestSchema),
+        client
+      );
+    }
+    if (isCheckoutSessionCancelRequest(request, this.options.basePath)) {
+      return this.cancelCheckoutSession(checkoutSessionId, client);
+    }
+    return this.updateCheckoutSession(
+      checkoutSessionId,
+      await parseJsonBody(request, ACPUpdateCheckoutSessionRequestSchema),
+      client,
+      requestContext
+    );
+  }
+  async createCheckoutSession(input, client, requestContext) {
+    const cart = await this.createCartForItems(input.items, client);
+    const checkout = await unwrapACPResult(
+      client.checkout.initiateCheckoutForCart({
+        cart,
+        billingAddress: input.fulfillment_address ? toReactionaryAddress(input.fulfillment_address) : void 0,
+        notificationEmail: input.buyer?.email,
+        notificationPhone: input.buyer?.phone_number
+      })
+    );
+    const state = {
+      id: `checkout_session_${crypto.randomUUID()}`,
+      cartId: cart.identifier.key,
+      checkoutId: checkout.identifier.key,
+      status: getCheckoutStatus(checkout),
+      buyer: input.buyer,
+      fulfillmentAddress: input.fulfillment_address
+    };
+    await this.checkoutSessionStore.put(state.id, state);
+    return jsonResponse(
+      await this.toACPCheckoutSession(state, checkout, client, requestContext),
+      { status: 201 }
+    );
+  }
+  async updateCheckoutSession(checkoutSessionId, input, client, requestContext) {
+    const state = await this.getRequiredCheckoutSessionState(checkoutSessionId);
+    let checkout = await this.getReactionaryCheckout(state, client);
+    let cartId = state.cartId;
+    if (input.items) {
+      const cart = await this.createCartForItems(input.items, client);
+      checkout = await unwrapACPResult(
+        client.checkout.initiateCheckoutForCart({
+          cart,
+          billingAddress: input.fulfillment_address ? toReactionaryAddress(input.fulfillment_address) : state.fulfillmentAddress ? toReactionaryAddress(state.fulfillmentAddress) : void 0,
+          notificationEmail: input.buyer?.email ?? state.buyer?.email,
+          notificationPhone: input.buyer?.phone_number ?? state.buyer?.phone_number
+        })
+      );
+      cartId = cart.identifier.key;
+    }
+    if (input.fulfillment_address) {
+      checkout = await unwrapACPResult(
+        client.checkout.setShippingAddress({
+          checkout: checkout.identifier,
+          shippingAddress: toReactionaryAddress(input.fulfillment_address)
+        })
+      );
+    }
+    if (input.fulfillment_option_id) {
+      checkout = await unwrapACPResult(
+        client.checkout.setShippingInstruction({
+          checkout: checkout.identifier,
+          shippingInstruction: {
+            shippingMethod: { key: input.fulfillment_option_id },
+            pickupPoint: "",
+            instructions: "",
+            consentForUnattendedDelivery: false
+          }
+        })
+      );
+    }
+    const updatedState = {
+      ...state,
+      cartId,
+      checkoutId: checkout.identifier.key,
+      status: getCheckoutStatus(checkout),
+      buyer: input.buyer ?? state.buyer,
+      fulfillmentAddress: input.fulfillment_address ?? state.fulfillmentAddress,
+      fulfillmentOptionId: input.fulfillment_option_id ?? state.fulfillmentOptionId
+    };
+    await this.checkoutSessionStore.put(checkoutSessionId, updatedState);
+    return jsonResponse(
+      await this.toACPCheckoutSession(
+        updatedState,
+        checkout,
+        client,
+        requestContext
+      )
+    );
+  }
+  async getCheckoutSession(checkoutSessionId, client, omitBody) {
+    const state = await this.checkoutSessionStore.get(checkoutSessionId);
+    if (!state) {
+      return acpErrorResponse(404, {
+        type: "invalid_request",
+        code: "missing",
+        message: `Checkout session not found: ${checkoutSessionId}`
+      });
+    }
+    const checkout = await this.getReactionaryCheckout(state, client);
+    return jsonResponse(
+      await this.toACPCheckoutSession(state, checkout, client),
+      { omitBody }
+    );
+  }
+  async completeCheckoutSession(checkoutSessionId, input, client) {
+    const state = await this.getRequiredCheckoutSessionState(checkoutSessionId);
+    if (state.status === "canceled") {
+      return acpErrorResponse(405, {
+        type: "invalid_request",
+        code: "invalid",
+        message: "Canceled checkout sessions cannot be completed."
+      });
+    }
+    let checkout = await this.getReactionaryCheckout(state, client);
+    checkout = await unwrapACPResult(
+      client.checkout.addPaymentInstruction({
+        checkout: checkout.identifier,
+        paymentInstruction: {
+          amount: checkout.price.grandTotal,
+          paymentMethod: toPaymentMethodIdentifier(input.payment_data.provider),
+          protocolData: [
+            {
+              key: "delegated_payment_token",
+              value: input.payment_data.token
+            }
+          ]
+        }
+      })
+    );
+    checkout = await unwrapACPResult(
+      client.checkout.finalizeCheckout({
+        checkout: checkout.identifier
+      })
+    );
+    const completedState = {
+      ...state,
+      status: "completed",
+      buyer: input.buyer ?? state.buyer,
+      orderId: checkout.resultingOrder?.key
+    };
+    await this.checkoutSessionStore.put(checkoutSessionId, completedState);
+    return jsonResponse(
+      await this.toACPCheckoutSession(completedState, checkout, client)
+    );
+  }
+  async cancelCheckoutSession(checkoutSessionId, client) {
+    const state = await this.getRequiredCheckoutSessionState(checkoutSessionId);
+    if (state.status === "completed" || state.status === "canceled") {
+      return acpErrorResponse(405, {
+        type: "invalid_request",
+        code: "invalid",
+        message: "Completed or canceled checkout sessions cannot be canceled."
+      });
+    }
+    const canceledState = {
+      ...state,
+      status: "canceled"
+    };
+    const checkout = await this.getReactionaryCheckout(canceledState, client);
+    await this.checkoutSessionStore.put(checkoutSessionId, canceledState);
+    return jsonResponse(
+      await this.toACPCheckoutSession(canceledState, checkout, client)
+    );
+  }
+  async createCartForItems(items, client) {
+    let cart = await unwrapACPResult(client.cart.createCart({}));
+    for (const item of items) {
+      cart = await unwrapACPResult(
+        client.cart.add({
+          cart: cart.identifier,
+          variant: { sku: item.id },
+          quantity: item.quantity
+        })
+      );
+    }
+    return cart;
+  }
+  async getRequiredCheckoutSessionState(checkoutSessionId) {
+    const state = await this.checkoutSessionStore.get(checkoutSessionId);
+    if (!state) {
+      throw new ACPHttpError(404, {
+        type: "invalid_request",
+        code: "missing",
+        message: `Checkout session not found: ${checkoutSessionId}`
+      });
+    }
+    return state;
+  }
+  async getReactionaryCheckout(state, client) {
+    return unwrapACPResult(
+      client.checkout.getById({
+        identifier: { key: state.checkoutId }
+      })
+    );
+  }
+  async toACPCheckoutSession(state, checkout, client, requestContext = createInitialRequestContext()) {
+    const fulfillmentOptions = await this.getFulfillmentOptions(
+      checkout,
+      client
+    );
+    return {
+      id: state.id,
+      ...state.buyer ? { buyer: state.buyer } : {},
+      payment_provider: await this.getPaymentProvider(checkout, client),
+      status: state.status === "completed" || state.status === "canceled" ? state.status : getCheckoutStatus(checkout),
+      currency: getCurrency(checkout, requestContext),
+      line_items: checkout.items.map(toACPLineItem),
+      ...state.fulfillmentAddress ? { fulfillment_address: state.fulfillmentAddress } : {},
+      fulfillment_options: fulfillmentOptions,
+      ...state.fulfillmentOptionId ? { fulfillment_option_id: state.fulfillmentOptionId } : checkout.shippingInstruction?.shippingMethod.key ? {
+        fulfillment_option_id: checkout.shippingInstruction.shippingMethod.key
+      } : {},
+      totals: toACPTotals(checkout),
+      ...state.orderId ? {
+        order: {
+          id: state.orderId,
+          checkout_session_id: state.id,
+          permalink_url: ""
+        }
+      } : {},
+      messages: [],
+      links: this.options.links ?? []
+    };
+  }
+  async getFulfillmentOptions(checkout, client) {
+    const result = await client.checkout.getAvailableShippingMethods({
+      checkout: checkout.identifier
+    });
+    if (!result.success) {
+      return [];
+    }
+    return result.value.map(toACPFulfillmentOption);
+  }
+  async getPaymentProvider(checkout, client) {
+    if (this.options.paymentProvider) {
+      return this.options.paymentProvider;
+    }
+    const result = await client.checkout.getAvailablePaymentMethods({
+      checkout: checkout.identifier
+    });
+    if (result.success) {
+      const supported = result.value.find(
+        (method) => ["stripe", "adyen", "braintree"].includes(
+          method.identifier.paymentProcessor
+        )
+      );
+      if (supported) {
+        return {
+          provider: supported.identifier.paymentProcessor,
+          supported_payment_methods: ["card"]
+        };
+      }
+    }
+    return {
+      provider: "stripe",
+      supported_payment_methods: ["card"]
+    };
+  }
+}
+class ACPHttpError extends Error {
+  constructor(status, body) {
+    super(body.message);
+    this.status = status;
+    this.body = body;
+  }
+  status;
+  body;
+}
+class ReactionaryACPSessionStore {
+  constructor(cache, ttlSeconds) {
+    this.cache = cache;
+    this.ttlSeconds = ttlSeconds;
+  }
+  cache;
+  ttlSeconds;
+  async get(sessionId) {
+    return await this.cache.get(
+      this.getCacheKey(sessionId),
+      SessionSchema
+    ) ?? void 0;
+  }
+  async put(sessionId, session) {
+    await this.cache.invalidate([this.getDependencyId(sessionId)]);
+    await this.cache.put(this.getCacheKey(sessionId), session, {
+      ttlSeconds: this.ttlSeconds,
+      dependencyIds: [this.getDependencyId(sessionId)]
+    });
+  }
+  getCacheKey(sessionId) {
+    return `${SESSION_CACHE_KEY_PREFIX}:${sessionId}`;
+  }
+  getDependencyId(sessionId) {
+    return `${SESSION_CACHE_KEY_PREFIX}:${sessionId}`;
+  }
+}
+class ReactionaryACPCheckoutSessionStore {
+  constructor(cache, ttlSeconds) {
+    this.cache = cache;
+    this.ttlSeconds = ttlSeconds;
+  }
+  cache;
+  ttlSeconds;
+  async get(checkoutSessionId) {
+    return await this.cache.get(
+      this.getCacheKey(checkoutSessionId),
+      ACPCheckoutSessionStateSchema
+    ) ?? void 0;
+  }
+  async put(checkoutSessionId, session) {
+    await this.cache.invalidate([this.getDependencyId(checkoutSessionId)]);
+    await this.cache.put(this.getCacheKey(checkoutSessionId), session, {
+      ttlSeconds: this.ttlSeconds,
+      dependencyIds: [this.getDependencyId(checkoutSessionId)]
+    });
+  }
+  getCacheKey(checkoutSessionId) {
+    return `${CHECKOUT_SESSION_CACHE_KEY_PREFIX}:${checkoutSessionId}`;
+  }
+  getDependencyId(checkoutSessionId) {
+    return `${CHECKOUT_SESSION_CACHE_KEY_PREFIX}:${checkoutSessionId}`;
+  }
+}
+function getSessionId(request) {
+  return request.headers.get(ACP_SESSION_ID_HEADER) ?? void 0;
+}
+function getOrCreateSessionId(request) {
+  return getSessionId(request) ?? crypto.randomUUID();
+}
+function getCheckoutSessionId(request, basePath) {
+  const pathname = getProtocolPathname(request, basePath);
+  const match = /^\/checkout_sessions\/([^/]+)(?:\/(?:complete|cancel))?$/.exec(
+    pathname
+  );
+  return match?.[1];
+}
+function getProductFeedId(request, basePath) {
+  const pathname = getProtocolPathname(request, basePath);
+  const match = /^\/product_feeds\/([^/]+)\/products$/.exec(pathname);
+  return match?.[1];
+}
+function isCheckoutSessionCompleteRequest(request, basePath) {
+  return getProtocolPathname(request, basePath).endsWith("/complete");
+}
+function isCheckoutSessionCancelRequest(request, basePath) {
+  return getProtocolPathname(request, basePath).endsWith("/cancel");
+}
+function getProtocolPathname(request, basePath = "/acp") {
+  const pathname = new URL(request.url).pathname;
+  if (pathname === basePath) {
+    return "/";
+  }
+  if (pathname.startsWith(`${basePath}/`)) {
+    return pathname.slice(basePath.length);
+  }
+  return pathname;
+}
+async function parseJsonBody(request, schema) {
+  try {
+    return schema.parse(await request.json());
+  } catch (error) {
+    throw new ACPHttpError(400, {
+      type: "invalid_request",
+      code: "invalid",
+      message: error instanceof Error ? error.message : "Invalid request body"
+    });
+  }
+}
+function jsonResponse(body, options = {}) {
+  const headers = new Headers(options.headers);
+  headers.set("content-type", "application/json; charset=utf-8");
+  return new Response(
+    options.omitBody ? null : JSON.stringify(body),
+    {
+      status: options.status ?? 200,
+      headers
+    }
+  );
+}
+function acpErrorResponse(status, body) {
+  return jsonResponse(body, { status });
+}
+function assertACPClient(client) {
+  const missing = getMissingACPClientOperations(client);
+  if (missing.length > 0) {
+    throw new Error(
+      `Reactionary ACP server cannot initialize because the client is missing required operations: ${missing.join(", ")}`
+    );
+  }
+}
+function toACPErrorResponse(error) {
+  if (error instanceof ACPHttpError) {
+    return acpErrorResponse(error.status, error.body);
+  }
+  return acpErrorResponse(500, {
+    type: "processing_error",
+    code: "internal_error",
+    message: error instanceof Error ? error.message : String(error)
+  });
+}
+function getMissingACPClientOperations(client) {
+  return [
+    ["cart.createCart", client.cart?.createCart],
+    ["cart.add", client.cart?.add],
+    ["cart.getById", client.cart?.getById],
+    ["checkout.initiateCheckoutForCart", client.checkout?.initiateCheckoutForCart],
+    ["checkout.getById", client.checkout?.getById],
+    ["checkout.setShippingAddress", client.checkout?.setShippingAddress],
+    ["checkout.getAvailableShippingMethods", client.checkout?.getAvailableShippingMethods],
+    ["checkout.getAvailablePaymentMethods", client.checkout?.getAvailablePaymentMethods],
+    ["checkout.setShippingInstruction", client.checkout?.setShippingInstruction],
+    ["checkout.addPaymentInstruction", client.checkout?.addPaymentInstruction],
+    ["checkout.finalizeCheckout", client.checkout?.finalizeCheckout],
+    ["productSearch.queryByTerm", client.productSearch?.queryByTerm],
+    ["product.getBySKU", client.product?.getBySKU],
+    ["price.getListPrice", client.price?.getListPrice],
+    ["price.getCustomerPrice", client.price?.getCustomerPrice],
+    ["inventory.getBySKU", client.inventory?.getBySKU]
+  ].filter(([, operation]) => typeof operation !== "function").map(([name]) => name);
+}
+async function unwrapACPResult(resultPromise) {
+  const result = await resultPromise;
+  if (!result.success) {
+    throw new ACPHttpError(400, {
+      type: "processing_error",
+      code: "reactionary_error",
+      message: JSON.stringify(result.error)
+    });
+  }
+  return result.value;
+}
+function getCheckoutStatus(checkout) {
+  return checkout.readyForFinalization ? "ready_for_payment" : "not_ready_for_payment";
+}
+function getCurrency(checkout, requestContext) {
+  return (checkout.price.grandTotal.currency ?? requestContext.languageContext.currencyCode).toLowerCase();
+}
+function toACPLineItem(item) {
+  const baseAmount = toMinorUnits(item.price.unitPrice.value * item.quantity);
+  const discount = toMinorUnits(item.price.totalDiscount.value);
+  const total = toMinorUnits(item.price.totalPrice.value);
+  return {
+    id: item.identifier.key,
+    item: {
+      id: item.variant.sku,
+      quantity: item.quantity
+    },
+    base_amount: baseAmount,
+    discount,
+    subtotal: Math.max(baseAmount - discount, 0),
+    tax: 0,
+    total
+  };
+}
+function toACPTotals(checkout) {
+  const base = toMinorUnits(checkout.price.totalProductPrice.value);
+  const discount = toMinorUnits(checkout.price.totalDiscount.value);
+  const subtotal = Math.max(base - discount, 0);
+  const fulfillment = toMinorUnits(checkout.price.totalShipping.value);
+  const tax = toMinorUnits(checkout.price.totalTax.value);
+  const total = toMinorUnits(checkout.price.grandTotal.value);
+  return [
+    {
+      type: "items_base_amount",
+      display_text: "Item(s) total",
+      amount: base
+    },
+    {
+      type: "items_discount",
+      display_text: "Item discount",
+      amount: discount
+    },
+    {
+      type: "subtotal",
+      display_text: "Subtotal",
+      amount: subtotal
+    },
+    {
+      type: "fulfillment",
+      display_text: "Fulfillment",
+      amount: fulfillment
+    },
+    {
+      type: "tax",
+      display_text: "Tax",
+      amount: tax
+    },
+    {
+      type: "total",
+      display_text: "Total",
+      amount: total
+    }
+  ];
+}
+function toACPFulfillmentOption(method) {
+  const amount = toMinorUnits(method.price.value);
+  return {
+    type: "shipping",
+    id: method.identifier.key,
+    title: method.name,
+    subtitle: method.deliveryTime,
+    carrier: method.carrier ?? "",
+    earliest_delivery_time: (/* @__PURE__ */ new Date()).toISOString(),
+    latest_delivery_time: (/* @__PURE__ */ new Date()).toISOString(),
+    subtotal: amount,
+    tax: 0,
+    total: amount
+  };
+}
+function toReactionaryAddress(address) {
+  const [firstName, ...lastNameParts] = address.name.split(" ");
+  return {
+    firstName: firstName ?? address.name,
+    lastName: lastNameParts.join(" "),
+    streetAddress: address.line_one,
+    streetNumber: "",
+    city: address.city,
+    region: address.state,
+    postalCode: address.postal_code,
+    countryCode: address.country
+  };
+}
+function toPaymentMethodIdentifier(provider) {
+  return {
+    method: "card",
+    name: provider,
+    paymentProcessor: provider
+  };
+}
+function toMinorUnits(value) {
+  return Math.max(Math.round(value * 100), 0);
+}
+function createFeedStream(chunks) {
+  const encoder = new TextEncoder();
+  const iterator = chunks[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const next = await iterator.next();
+      if (next.done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(
+        typeof next.value === "string" ? encoder.encode(next.value) : next.value
+      );
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  });
+}
+async function toWebRequest(request) {
+  const headers = toWebHeaders(request.headers);
+  const url = new URL(
+    request.url ?? "/",
+    `http://${request.headers.host ?? "localhost"}`
+  );
+  const body = await readNodeRequestBody(request);
+  return new Request(url, {
+    method: request.method,
+    headers,
+    body
+  });
+}
+function toWebHeaders(headers) {
+  const webHeaders = new Headers();
+  for (const [key, value] of Object.entries(headers)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        webHeaders.append(key, entry);
+      }
+      continue;
+    }
+    webHeaders.set(key, value);
+  }
+  return webHeaders;
+}
+async function readNodeRequestBody(request) {
+  if (request.method === "GET" || request.method === "HEAD") {
+    return null;
+  }
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  if (chunks.length === 0) {
+    return null;
+  }
+  return Buffer.concat(chunks);
+}
+async function sendWebResponse(response, webResponse) {
+  response.writeHead(
+    webResponse.status,
+    Object.fromEntries(webResponse.headers.entries())
+  );
+  if (webResponse.body) {
+    response.end(Buffer.from(await webResponse.arrayBuffer()));
+    return;
+  }
+  response.end();
+}
+export {
+  ReactionaryACPServer
+};