@sixtyninecommerce/admin 0.10.0 → 0.11.0

package/dist/orders/drafts.js

@@ -0,0 +1,771 @@
+/**
+ * `admin.orders.drafts`: staff build an order by hand, one step at a time (headless spec §9.2
+ * `orders` "draft-order editing"; plan W10-21).
+ *
+ * A draft is an order in the `Draft` state that only staff can see. Each method here changes
+ * one thing about it and answers the draft as it then stands; `cloneFrom` fills it from an
+ * earlier order, and `place` turns it into a placed order with its payment recorded.
+ *
+ * `orders.createOrRecover` is the other way to make an order: ONE keyed call that composes a
+ * whole order an external system already decided (its reference, its lines, its prices). This
+ * module is the builder a person drives: a line can carry a manual price with a reason, a variant
+ * can be on two lines, and the customer, shipping and minimum are settled step by step.
+ *
+ * **Only drafts.** Every write refuses an order that is not a `Draft` with `ORDER_NOT_DRAFT`
+ * (`BusinessRuleError`, 422): a shopper's cart, a till sale or a placed order is changed through
+ * its own door (`orders.planEdit` / `orders.commitEdit` for a placed one). A till's held sale is
+ * refused `POS_CART_HELD`. An order of another store, or none, is core's `ENTITY_NOT_FOUND`
+ * (`NotFoundError`, 404).
+ *
+ * **Only `place` records money.** A draft bills nobody, so the editing methods take no
+ * idempotency key and repeating one repeats the edit (adding a line twice adds it twice). Three
+ * methods are keyed: `place` (it records the order's payment), `cloneFrom` (it replaces the
+ * draft's contents) and `saveAddresses` (it can add an entry to the customer's address book). A
+ * repeat of one of them under the same key answers the first call's result.
+ */
+import { BusinessRuleError, errorFromErrorResult, isErrorResult, idempotencyKey as mintIdempotencyKey, UpstreamError, ValidationError, } from '@sixtyninecommerce/core';
+import { assertDeleted, fieldOf } from '../catalog/types.js';
+import { redactionWatcher } from '../customer-data-redaction.js';
+/**
+ * How long `cloneFrom` waits for its answer. The engine copies an order in ONE call and one
+ * transaction, adding its lines one by one, so the call lasts as long as the whole copy; the
+ * default 15 s aborted the copy of a large order the engine went on to finish. Measured on a dev
+ * stack under heavy load (5-minute load average 34): 164 lines copied in 47 s, about 0.3 s a
+ * line, so the default ran out past some 50 lines and this covers some 300. Well under the
+ * engine's five-minute idempotency claim, so a repeat under the same key after this runs out
+ * meets the first attempt's claim (`IDEMPOTENCY_IN_PROGRESS`) instead of starting a second copy.
+ */
+export const DRAFT_CLONE_TIMEOUT_MS = 90_000;
+/**
+ * `addLine` and `adjustLine` asked for more than the stock allows. The engine took what it could
+ * and answers the draft as it now stands, so this is a partial success to show, not a refusal to
+ * retry: `INSUFFICIENT_STOCK` (`BusinessRuleError`, 422). Read the line's quantity off `order`.
+ */
+export class DraftInsufficientStockError extends BusinessRuleError {
+    /**
+     * The engine's own figure, which means a different thing per method:
+     * - `addLine`: how many units the add could TAKE. When the add merged into a line the draft
+     *   already had, the line holds its old quantity plus this. `0` means nothing was added.
+     * - `adjustLine`: the quantity the line holds now.
+     */
+    quantityAvailable;
+    /** The draft as the engine left it. */
+    order;
+    constructor(init, quantityAvailable, order) {
+        super({ ...init, status: 422 });
+        this.quantityAvailable = quantityAvailable;
+        this.order = order;
+    }
+}
+const ORDER_ADDRESS_FIELDS = /* GraphQL */ `
+  fullName
+  company
+  streetLine1
+  streetLine2
+  city
+  province
+  postalCode
+  country
+  countryCode
+  phoneNumber
+`;
+export const DRAFT_ORDER_FIELDS = /* GraphQL */ `
+  id
+  code
+  state
+  currencyCode
+  subTotal
+  subTotalWithTax
+  shipping
+  shippingWithTax
+  total
+  totalWithTax
+  customer {
+    id
+    firstName
+    lastName
+    emailAddress
+  }
+  lines {
+    id
+    quantity
+    unitPrice
+    unitPriceWithTax
+    listPriceIncludesTax
+    linePrice
+    linePriceWithTax
+    productVariant {
+      id
+      name
+      sku
+    }
+    customFields {
+      unitPriceOverride
+      priceOverrideReason
+      unitPriceImported
+    }
+  }
+  shippingLines {
+    id
+    price
+    priceWithTax
+    shippingMethod {
+      id
+      code
+      name
+    }
+  }
+  couponCodes
+  shippingAddress {
+    ${ORDER_ADDRESS_FIELDS}
+  }
+  billingAddress {
+    ${ORDER_ADDRESS_FIELDS}
+  }
+  customFields {
+    paymentConditionCode
+    paymentTermsDays
+    poNumber
+    orderNotes
+    requestedDeliveryDate
+    customerShippingAddressId
+    customerBillingAddressId
+    shippingAddressIsTemporary
+    billingAddressIsTemporary
+  }
+`;
+/** The refusals a line door answers, each with the field that carries its reason. */
+const LINE_REFUSALS = /* GraphQL */ `
+  ... on OrderInterceptorError {
+    interceptorError
+  }
+  ... on InsufficientStockError {
+    quantityAvailable
+    order {
+      ${DRAFT_ORDER_FIELDS}
+    }
+  }
+  ... on ErrorResult {
+    errorCode
+    message
+  }
+`;
+export const CREATE_DRAFT_ORDER_MUTATION = /* GraphQL */ `
+  mutation DraftsCreate {
+    createDraftOrder {
+      ${DRAFT_ORDER_FIELDS}
+    }
+  }
+`;
+export const DELETE_DRAFT_ORDER_MUTATION = /* GraphQL */ `
+  mutation DraftsDelete($orderId: ID!) {
+    deleteDraftOrder(orderId: $orderId) {
+      result
+      message
+    }
+  }
+`;
+export const SET_DRAFT_CUSTOMER_MUTATION = /* GraphQL */ `
+  mutation DraftsSetCustomer($orderId: ID!, $customerId: ID!) {
+    setCustomerForDraftOrder(orderId: $orderId, customerId: $customerId) {
+      ... on Order {
+        ${DRAFT_ORDER_FIELDS}
+      }
+      ... on ErrorResult {
+        errorCode
+        message
+      }
+    }
+  }
+`;
+export const ADD_DRAFT_LINE_MUTATION = /* GraphQL */ `
+  mutation DraftsAddLine($orderId: ID!, $input: AddItemToDraftOrderInput!) {
+    addItemToDraftOrder(orderId: $orderId, input: $input) {
+      ... on Order {
+        ${DRAFT_ORDER_FIELDS}
+      }
+      ${LINE_REFUSALS}
+    }
+  }
+`;
+export const ADJUST_DRAFT_LINE_MUTATION = /* GraphQL */ `
+  mutation DraftsAdjustLine($orderId: ID!, $input: AdjustDraftOrderLineInput!) {
+    adjustDraftOrderLine(orderId: $orderId, input: $input) {
+      ... on Order {
+        ${DRAFT_ORDER_FIELDS}
+      }
+      ${LINE_REFUSALS}
+    }
+  }
+`;
+export const REMOVE_DRAFT_LINE_MUTATION = /* GraphQL */ `
+  mutation DraftsRemoveLine($orderId: ID!, $orderLineId: ID!) {
+    removeDraftOrderLine(orderId: $orderId, orderLineId: $orderLineId) {
+      ... on Order {
+        ${DRAFT_ORDER_FIELDS}
+      }
+      ... on OrderInterceptorError {
+        interceptorError
+      }
+      ... on ErrorResult {
+        errorCode
+        message
+      }
+    }
+  }
+`;
+export const SET_DRAFT_FIELDS_MUTATION = /* GraphQL */ `
+  mutation DraftsSetFields($orderId: ID!, $input: UpdateOrderInput!) {
+    setDraftOrderCustomFields(orderId: $orderId, input: $input) {
+      ${DRAFT_ORDER_FIELDS}
+    }
+  }
+`;
+const ADDRESS_DEFAULT_FIELDS = /* GraphQL */ `
+  source
+  customerAddressId
+  address {
+    fullName
+    company
+    streetLine1
+    streetLine2
+    city
+    province
+    postalCode
+    countryCode
+    phoneNumber
+  }
+  temporary
+  temporaryInferred
+`;
+export const DRAFT_ADDRESS_DEFAULTS_QUERY = /* GraphQL */ `
+  query DraftsAddressDefaults($orderId: ID!) {
+    draftOrderAddressDefaults(orderId: $orderId) {
+      shipping {
+        ${ADDRESS_DEFAULT_FIELDS}
+      }
+      billing {
+        ${ADDRESS_DEFAULT_FIELDS}
+      }
+      billingSameAsShipping
+    }
+  }
+`;
+export const SAVE_DRAFT_ADDRESSES_MUTATION = /* GraphQL */ `
+  mutation DraftsSaveAddresses(
+    $orderId: ID!
+    $input: SaveDraftOrderAddressesInput!
+    $idempotencyKey: String
+  ) {
+    saveDraftOrderAddresses(orderId: $orderId, input: $input, idempotencyKey: $idempotencyKey) {
+      order {
+        ${DRAFT_ORDER_FIELDS}
+      }
+      createdAddressIds
+    }
+  }
+`;
+export const SET_DRAFT_SHIPPING_ADDRESS_MUTATION = /* GraphQL */ `
+  mutation DraftsSetShippingAddress($orderId: ID!, $input: CreateAddressInput!) {
+    setDraftOrderShippingAddress(orderId: $orderId, input: $input) {
+      ${DRAFT_ORDER_FIELDS}
+    }
+  }
+`;
+export const SET_DRAFT_BILLING_ADDRESS_MUTATION = /* GraphQL */ `
+  mutation DraftsSetBillingAddress($orderId: ID!, $input: CreateAddressInput!) {
+    setDraftOrderBillingAddress(orderId: $orderId, input: $input) {
+      ${DRAFT_ORDER_FIELDS}
+    }
+  }
+`;
+export const UNSET_DRAFT_SHIPPING_ADDRESS_MUTATION = /* GraphQL */ `
+  mutation DraftsUnsetShippingAddress($orderId: ID!) {
+    unsetDraftOrderShippingAddress(orderId: $orderId) {
+      ${DRAFT_ORDER_FIELDS}
+    }
+  }
+`;
+export const UNSET_DRAFT_BILLING_ADDRESS_MUTATION = /* GraphQL */ `
+  mutation DraftsUnsetBillingAddress($orderId: ID!) {
+    unsetDraftOrderBillingAddress(orderId: $orderId) {
+      ${DRAFT_ORDER_FIELDS}
+    }
+  }
+`;
+export const DRAFT_SHIPPING_QUOTES_QUERY = /* GraphQL */ `
+  query DraftsShippingQuotes($orderId: ID!) {
+    eligibleShippingMethodsForDraftOrder(orderId: $orderId) {
+      id
+      code
+      name
+      description
+      price
+      priceWithTax
+      metadata
+      isPreferred
+      isDeliveryTermsEligible
+    }
+  }
+`;
+const SHIPPING_RESULT = /* GraphQL */ `
+  ... on Order {
+    ${DRAFT_ORDER_FIELDS}
+  }
+  ... on ErrorResult {
+    errorCode
+    message
+  }
+`;
+export const SELECT_DRAFT_DELIVERY_MUTATION = /* GraphQL */ `
+  mutation DraftsSelectDelivery($orderId: ID!, $shippingMethodId: ID!) {
+    selectDraftOrderDeliveryMethod(orderId: $orderId, shippingMethodId: $shippingMethodId) {
+      ${SHIPPING_RESULT}
+    }
+  }
+`;
+export const APPLY_PREFERRED_DRAFT_DELIVERY_MUTATION = /* GraphQL */ `
+  mutation DraftsApplyPreferredDelivery($orderId: ID!) {
+    applyPreferredDeliveryMethodToDraftOrder(orderId: $orderId) {
+      ${SHIPPING_RESULT}
+    }
+  }
+`;
+export const SET_DRAFT_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation DraftsSetShippingMethod($orderId: ID!, $shippingMethodId: ID!) {
+    setDraftOrderShippingMethod(orderId: $orderId, shippingMethodId: $shippingMethodId) {
+      ${SHIPPING_RESULT}
+    }
+  }
+`;
+export const REPRICE_DRAFT_MUTATION = /* GraphQL */ `
+  mutation DraftsReprice($orderId: ID!) {
+    repriceDraftOrder(orderId: $orderId) {
+      success
+      changed
+      linesRepriced
+      error
+      errorCode
+    }
+  }
+`;
+/**
+ * The same mutation as an engine released before 2026-10-10 serves it, with no `errorCode`.
+ * Used only when that engine refuses the current document at validation.
+ */
+export const REPRICE_DRAFT_LEGACY_MUTATION = /* GraphQL */ `
+  mutation DraftsRepriceLegacy($orderId: ID!) {
+    repriceDraftOrder(orderId: $orderId) {
+      success
+      changed
+      linesRepriced
+      error
+    }
+  }
+`;
+export const DRAFT_MINIMUM_STATUS_QUERY = /* GraphQL */ `
+  query DraftsMinimumStatus($orderId: ID!) {
+    draftOrderMinimumStatus(orderId: $orderId) {
+      belowMinimum
+      message
+      overridden
+      overriddenAt
+      overriddenBy
+      reason
+    }
+  }
+`;
+export const OVERRIDE_DRAFT_MINIMUM_MUTATION = /* GraphQL */ `
+  mutation DraftsMinimumOverride($orderId: ID!, $reason: String) {
+    overrideDraftOrderMinimum(orderId: $orderId, reason: $reason) {
+      id
+    }
+  }
+`;
+export const CLEAR_DRAFT_MINIMUM_MUTATION = /* GraphQL */ `
+  mutation DraftsMinimumClear($orderId: ID!) {
+    clearDraftOrderMinimumOverride(orderId: $orderId) {
+      id
+    }
+  }
+`;
+export const APPLY_DRAFT_COUPON_MUTATION = /* GraphQL */ `
+  mutation DraftsApplyCoupon($orderId: ID!, $couponCode: String!) {
+    applyCouponCodeToDraftOrder(orderId: $orderId, couponCode: $couponCode) {
+      ... on Order {
+        ${DRAFT_ORDER_FIELDS}
+      }
+      ... on ErrorResult {
+        errorCode
+        message
+      }
+    }
+  }
+`;
+export const REMOVE_DRAFT_COUPON_MUTATION = /* GraphQL */ `
+  mutation DraftsRemoveCoupon($orderId: ID!, $couponCode: String!) {
+    removeCouponCodeFromDraftOrder(orderId: $orderId, couponCode: $couponCode) {
+      ${DRAFT_ORDER_FIELDS}
+    }
+  }
+`;
+export const PLACE_DRAFT_MUTATION = /* GraphQL */ `
+  mutation DraftsPlace($input: PlaceDraftOrderInput!, $idempotencyKey: String!) {
+    placeDraftOrder(input: $input, idempotencyKey: $idempotencyKey) {
+      id
+      code
+      state
+      currencyCode
+      totalWithTax
+      payments {
+        id
+        state
+        method
+        amount
+        transactionId
+      }
+    }
+  }
+`;
+export const CLONE_DRAFT_MUTATION = /* GraphQL */ `
+  mutation DraftsCloneFrom(
+    $orderId: ID!
+    $sourceOrderId: ID!
+    $reasonCode: String
+    $idempotencyKey: String!
+  ) {
+    cloneOrderToDraftOrder(
+      orderId: $orderId
+      sourceOrderId: $sourceOrderId
+      reasonCode: $reasonCode
+      idempotencyKey: $idempotencyKey
+    ) {
+      order {
+        ${DRAFT_ORDER_FIELDS}
+      }
+      skipped {
+        sourceLineId
+        reason
+        message
+      }
+      clamped {
+        sourceLineId
+        quantityAdded
+      }
+      shippingMethodApplied
+    }
+  }
+`;
+/**
+ * The draft, or the refusal as its error. An interceptor's `message` is core's template ("An
+ * error occurred"); its reason is in `interceptorError`. A stock clamp keeps the line, so it
+ * carries the quantity and the draft.
+ */
+function draftOrThrow(answer, field) {
+    if (answer == null)
+        throw unexpected(field);
+    if (!isErrorResult(answer))
+        return answer;
+    if (answer.errorCode === 'INSUFFICIENT_STOCK_ERROR' && answer.order) {
+        // Core's own sentence: its figure is the units an add could take, or an adjusted line's new
+        // quantity, so a sentence composed here would misstate one of the two.
+        throw new DraftInsufficientStockError({
+            code: 'INSUFFICIENT_STOCK',
+            message: answer.message,
+            service: 'vendure',
+            details: [{ field: 'quantity', code: 'INSUFFICIENT_STOCK', message: answer.message }],
+        }, answer.quantityAvailable ?? 0, answer.order);
+    }
+    const reason = typeof answer.interceptorError === 'string' ? answer.interceptorError.trim() : '';
+    throw errorFromErrorResult(reason === '' ? answer : { ...answer, message: reason });
+}
+/**
+ * A request the engine refused before running anything: Apollo answers a document that fails
+ * validation with HTTP 400, which `@sixtyninecommerce/core` reads as `ValidationError`
+ * `BAD_REQUEST` (it reads the GraphQL error document only on a 5xx); an answer at 200 would carry
+ * `GRAPHQL_VALIDATION_FAILED`. An error a resolver threw never carries either code.
+ */
+function rejectedBeforeRunning(error) {
+    return (error instanceof ValidationError &&
+        (error.code === 'BAD_REQUEST' || error.code === 'GRAPHQL_VALIDATION_FAILED'));
+}
+function unexpected(field) {
+    return new UpstreamError({
+        code: 'UNEXPECTED_RESPONSE',
+        message: `The engine answered without "${field}".`,
+        status: 502,
+        service: 'vendure',
+    });
+}
+/** The key a caller retries under, on an error of a call whose key it did not choose. */
+function withAttemptKey(error, key) {
+    if (error !== null && typeof error === 'object' && !('idempotencyKey' in error)) {
+        Object.defineProperty(error, 'idempotencyKey', { value: key, enumerable: true });
+    }
+    return error;
+}
+/** Line custom fields, from the three-state inputs: an absent key stays absent. */
+function lineCustomFields(input) {
+    const fields = {};
+    for (const key of ['unitPriceOverride', 'priceOverrideReason', 'unitPriceImported']) {
+        if (input[key] !== undefined)
+            fields[key] = input[key];
+    }
+    return Object.keys(fields).length > 0 ? fields : undefined;
+}
+const ADDRESS_INPUT_FIELDS = [
+    'fullName',
+    'company',
+    'streetLine1',
+    'streetLine2',
+    'city',
+    'province',
+    'postalCode',
+    'countryCode',
+    'phoneNumber',
+];
+/** The typed address as the engine takes it: its own nine fields, an unset one left out. */
+function addressInput(address) {
+    const input = {};
+    for (const key of ADDRESS_INPUT_FIELDS) {
+        const value = address[key];
+        if (value != null)
+            input[key] = value;
+    }
+    return input;
+}
+/** One side as the engine takes it: the saved address's id, or the typed address. */
+function addressSide(side) {
+    if ('customerAddressId' in side)
+        return { customerAddressId: side.customerAddressId };
+    return {
+        address: addressInput(side.address),
+        ...(side.temporary === true ? { temporary: true } : {}),
+    };
+}
+function lineInput(input, base) {
+    const customFields = lineCustomFields(input);
+    return {
+        ...base,
+        ...(customFields ? { customFields } : {}),
+        // Only when chosen: an engine without the discount-reason layer refuses the field.
+        ...(input.reasonCode ? { reasonCode: input.reasonCode } : {}),
+    };
+}
+export function createOrderDraftsModule(transport, getModule) {
+    /** One draft-answering call: the redaction stamp, and the union read through `draftOrThrow`. */
+    async function draftCall(document, field, variables, options) {
+        const redaction = redactionWatcher();
+        const data = await transport.graphql({ api: 'admin', query: document, variables, onExtensions: redaction.onExtensions }, options);
+        try {
+            return redaction.mark(draftOrThrow(data?.[field], field));
+        }
+        catch (error) {
+            if (error instanceof DraftInsufficientStockError)
+                redaction.mark(error.order);
+            throw error;
+        }
+    }
+    const minimum = {
+        async status(orderId, options) {
+            return fieldOf(transport, DRAFT_MINIMUM_STATUS_QUERY, 'draftOrderMinimumStatus', { orderId }, options);
+        },
+        async override(orderId, options) {
+            const reason = options?.reason?.trim();
+            await fieldOf(transport, OVERRIDE_DRAFT_MINIMUM_MUTATION, 'overrideDraftOrderMinimum', { orderId, reason: reason ? reason : null }, options);
+        },
+        async clear(orderId, options) {
+            await fieldOf(transport, CLEAR_DRAFT_MINIMUM_MUTATION, 'clearDraftOrderMinimumOverride', { orderId }, options);
+        },
+    };
+    const coupons = {
+        apply(orderId, couponCode, options) {
+            return draftCall(APPLY_DRAFT_COUPON_MUTATION, 'applyCouponCodeToDraftOrder', { orderId, couponCode }, options);
+        },
+        remove(orderId, couponCode, options) {
+            return draftCall(REMOVE_DRAFT_COUPON_MUTATION, 'removeCouponCodeFromDraftOrder', { orderId, couponCode }, options);
+        },
+    };
+    return {
+        create(options) {
+            return draftCall(CREATE_DRAFT_ORDER_MUTATION, 'createDraftOrder', {}, options);
+        },
+        get: getModule.get,
+        async delete(orderId, options) {
+            assertDeleted('ORDER_NOT_DELETED', [
+                await fieldOf(transport, DELETE_DRAFT_ORDER_MUTATION, 'deleteDraftOrder', { orderId }, options),
+            ]);
+        },
+        setCustomer(orderId, customerId, options) {
+            return draftCall(SET_DRAFT_CUSTOMER_MUTATION, 'setCustomerForDraftOrder', { orderId, customerId }, options);
+        },
+        addLine(orderId, input, options) {
+            return draftCall(ADD_DRAFT_LINE_MUTATION, 'addItemToDraftOrder', {
+                orderId,
+                input: lineInput(input, {
+                    productVariantId: input.productVariantId,
+                    quantity: input.quantity,
+                }),
+            }, options);
+        },
+        adjustLine(orderId, lineId, input, options) {
+            return draftCall(ADJUST_DRAFT_LINE_MUTATION, 'adjustDraftOrderLine', { orderId, input: lineInput(input, { orderLineId: lineId, quantity: input.quantity }) }, options);
+        },
+        removeLine(orderId, lineId, options) {
+            return draftCall(REMOVE_DRAFT_LINE_MUTATION, 'removeDraftOrderLine', { orderId, orderLineId: lineId }, options);
+        },
+        setFields(orderId, fields, options) {
+            const customFields = {};
+            for (const [key, value] of Object.entries(fields)) {
+                if (value !== undefined)
+                    customFields[key] = value;
+            }
+            return draftCall(SET_DRAFT_FIELDS_MUTATION, 'setDraftOrderCustomFields', 
+            // `UpdateOrderInput.id` is required by the schema even though the door names the order.
+            { orderId, input: { id: orderId, customFields } }, options);
+        },
+        async addressDefaults(orderId, options) {
+            const redaction = redactionWatcher();
+            const data = await transport.graphql({
+                api: 'admin',
+                query: DRAFT_ADDRESS_DEFAULTS_QUERY,
+                variables: { orderId },
+                onExtensions: redaction.onExtensions,
+            }, options);
+            if (data?.draftOrderAddressDefaults == null)
+                throw unexpected('draftOrderAddressDefaults');
+            return redaction.mark(data.draftOrderAddressDefaults);
+        },
+        async saveAddresses(orderId, input, options) {
+            const redaction = redactionWatcher();
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SAVE_DRAFT_ADDRESSES_MUTATION,
+                variables: {
+                    orderId,
+                    input: {
+                        shipping: addressSide(input.shipping),
+                        ...('billing' in input
+                            ? { billing: addressSide(input.billing) }
+                            : { billingSameAsShipping: true }),
+                    },
+                    idempotencyKey: options?.idempotencyKey,
+                },
+                onExtensions: redaction.onExtensions,
+            }, options);
+            const saved = data?.saveDraftOrderAddresses;
+            if (saved?.order == null)
+                throw unexpected('saveDraftOrderAddresses');
+            redaction.mark(saved.order);
+            return saved;
+        },
+        setShippingAddress(orderId, address, options) {
+            return draftCall(SET_DRAFT_SHIPPING_ADDRESS_MUTATION, 'setDraftOrderShippingAddress', { orderId, input: addressInput(address) }, options);
+        },
+        setBillingAddress(orderId, address, options) {
+            return draftCall(SET_DRAFT_BILLING_ADDRESS_MUTATION, 'setDraftOrderBillingAddress', { orderId, input: addressInput(address) }, options);
+        },
+        unsetShippingAddress(orderId, options) {
+            return draftCall(UNSET_DRAFT_SHIPPING_ADDRESS_MUTATION, 'unsetDraftOrderShippingAddress', { orderId }, options);
+        },
+        unsetBillingAddress(orderId, options) {
+            return draftCall(UNSET_DRAFT_BILLING_ADDRESS_MUTATION, 'unsetDraftOrderBillingAddress', { orderId }, options);
+        },
+        async shippingQuotes(orderId, options) {
+            return fieldOf(transport, DRAFT_SHIPPING_QUOTES_QUERY, 'eligibleShippingMethodsForDraftOrder', { orderId }, options);
+        },
+        selectDelivery(orderId, shippingMethodId, options) {
+            return draftCall(SELECT_DRAFT_DELIVERY_MUTATION, 'selectDraftOrderDeliveryMethod', { orderId, shippingMethodId }, options);
+        },
+        applyPreferredDelivery(orderId, options) {
+            return draftCall(APPLY_PREFERRED_DRAFT_DELIVERY_MUTATION, 'applyPreferredDeliveryMethodToDraftOrder', { orderId }, options);
+        },
+        setShippingMethod(orderId, shippingMethodId, options) {
+            return draftCall(SET_DRAFT_SHIPPING_METHOD_MUTATION, 'setDraftOrderShippingMethod', { orderId, shippingMethodId }, options);
+        },
+        async reprice(orderId, options) {
+            let answer;
+            try {
+                answer = await fieldOf(transport, REPRICE_DRAFT_MUTATION, 'repriceDraftOrder', { orderId }, options);
+            }
+            catch (error) {
+                // An engine before `errorCode` refuses the whole document at validation, before the
+                // resolver runs, so asking again with the older document cannot re-price twice. A
+                // dashboard deployed ahead of its engine would otherwise fail every draft it opens.
+                if (!rejectedBeforeRunning(error))
+                    throw error;
+                answer = await fieldOf(transport, REPRICE_DRAFT_LEGACY_MUTATION, 'repriceDraftOrder', { orderId }, options);
+            }
+            if (!answer.success) {
+                throw errorFromErrorResult({
+                    errorCode: answer.errorCode ?? 'DRAFT_REPRICE_REFUSED',
+                    message: answer.error ?? 'The draft could not be re-priced.',
+                });
+            }
+            return { changed: answer.changed, linesRepriced: answer.linesRepriced };
+        },
+        async cloneFrom(orderId, sourceOrderId, options) {
+            const key = options?.idempotencyKey ?? mintIdempotencyKey();
+            const reasonCode = options?.reasonCode?.trim();
+            const redaction = redactionWatcher();
+            try {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: CLONE_DRAFT_MUTATION,
+                    variables: {
+                        orderId,
+                        sourceOrderId,
+                        // Only when chosen: a blank reason is none.
+                        reasonCode: reasonCode ? reasonCode : null,
+                        idempotencyKey: key,
+                    },
+                    onExtensions: redaction.onExtensions,
+                }, { timeoutMs: DRAFT_CLONE_TIMEOUT_MS, ...options, idempotencyKey: key });
+                const cloned = data?.cloneOrderToDraftOrder;
+                if (cloned?.order == null)
+                    throw unexpected('cloneOrderToDraftOrder');
+                redaction.mark(cloned.order);
+                return { ...cloned, idempotencyKey: key };
+            }
+            catch (error) {
+                throw withAttemptKey(error, key);
+            }
+        },
+        async place(input, options) {
+            const key = options?.idempotencyKey ?? mintIdempotencyKey();
+            const { payment } = input;
+            try {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: PLACE_DRAFT_MUTATION,
+                    variables: {
+                        input: {
+                            orderId: input.orderId,
+                            // Three states: left out keeps the draft's terms, `null` clears the override.
+                            ...(input.paymentConditionCode !== undefined
+                                ? { paymentConditionCode: input.paymentConditionCode }
+                                : {}),
+                            payment: {
+                                methodCode: payment.methodCode,
+                                received: payment.received,
+                                ...(payment.transactionId != null
+                                    ? { transactionId: payment.transactionId }
+                                    : {}),
+                                ...(payment.metadata != null ? { metadata: payment.metadata } : {}),
+                            },
+                        },
+                        idempotencyKey: key,
+                    },
+                }, { ...options, idempotencyKey: key });
+                if (data?.placeDraftOrder == null)
+                    throw unexpected('placeDraftOrder');
+                return { ...data.placeDraftOrder, idempotencyKey: key };
+            }
+            catch (error) {
+                throw withAttemptKey(error, key);
+            }
+        },
+        minimum,
+        coupons,
+    };
+}