@sixtyninecommerce/admin 0.10.0 → 0.11.0

package/dist/fulfillments/warehouse.js

@@ -0,0 +1,914 @@
+/**
+ * `admin.fulfillments.warehouse`: the pick/pack/ship workspace (headless W10-37; spec
+ * `decoupling-fulfillments`, ADR `2026-09-10-warehouse-access-model`).
+ *
+ * The warehouse API is the fulfillment's own API, built for warehouse staff who have no
+ * `ReadOrder`: it is PRICE-FREE (no order totals, prices, payment amounts, customer e-mail or
+ * billing address; a payment shows as a `paid | due | not_required` badge) and LOCATION-SCOPED.
+ * `detachPreview` is the one exception: it names money, so it is the order API's (`ReadOrder`).
+ *
+ * **Who may act where.** Reads need `ReadFulfillment` (or `UpdateOrder`), writes
+ * `UpdateFulfillment` (or `UpdateOrder`), and the store needs the `warehouse` entitlement
+ * (`WAREHOUSE_NOT_ENABLED` otherwise). `mine`, `demand` and `handlers` also serve office staff of a
+ * store without the entitlement: the shared create flow reads them. A caller holding `UpdateOrder`
+ * is office staff and works in every warehouse of the store, plus the fulfillments with no recorded
+ * warehouse. Anyone else works only in the warehouses a store admin assigned to them (none
+ * assigned: nothing). An API token or app restricted to stock locations is held to those
+ * locations whatever it holds, and never sees a fulfillment with no recorded warehouse.
+ *
+ * **One refusal for "not found" and "not yours":** `LOCATION_OUT_OF_SCOPE`, for a fulfillment or a
+ * warehouse that does not exist, belongs to another store, or is outside the caller's warehouses.
+ * The API never confirms that a fulfillment exists outside the caller's scope.
+ *
+ * **The stages.** With the entitlement a fulfillment moves `Pending → Picking` (`claim`),
+ * `Picking → Pending` (`unclaim`: the claimer or office staff), `Picking → Packed` (`pack`),
+ * `Packed → Picking` (`reopen`, while no carrier booking is active), `→ Shipped` from `Packed`, or
+ * from `Pending` for a 3PL or a manual method (`ship`), and `→ Delivered` from `Shipped` or
+ * `Pending` (`deliver`). A 3PL (`mode: outsourced`) skips picking and packing: creating it was the
+ * handoff. A held order, addresses that diverged in a consolidated fulfillment, a carrier booking
+ * still missing and, on a store that requires it, an order not paid in full each refuse shipping
+ * (`ORDER_ON_HOLD`, `CONSOLIDATION_ADDRESS_DIVERGED`, `BOOKING_REQUIRED`, `ORDER_NOT_COVERED`).
+ *
+ * **Refusals are coded errors.** A write's `WarehouseError` union member is thrown as a
+ * `PlatformError` carrying its `code` (`ALREADY_CLAIMED`, `INVALID_STAGE_TRANSITION`,
+ * `LOCATION_OUT_OF_SCOPE`, …), classified by the same code rules as the errors the warehouse
+ * queries throw, so one refusal reaches you as one class whichever call answered it:
+ * `INVALID_INPUT` is a `ValidationError` (400), `HANDLER_NOT_FOUND` (a carrier code the engine
+ * does not know) a `NotFoundError` (404), and the warehouse's other codes `BusinessRuleError`
+ * (422). A `COMBINE_RULE_VIOLATED` names the part of the rule that broke in `details[0].field`.
+ * Bulk `ship` and `deliver` report each fulfillment's refusal as data and throw only for the call
+ * as a whole. Three refusals come from before the warehouse decides: a missing permission is
+ * `FORBIDDEN`, a carrier of a plugin the store does not have (`setHandler`, `book`) is
+ * `PLUGIN_ACCESS_DENIED` (both `PermissionDeniedError`, 403), and an id that is not a uuid is
+ * `ENTITY_NOT_FOUND` (`NotFoundError`).
+ *
+ * **Idempotency keys: `append` only.** Every other write is safe to repeat: the stage it needs is
+ * gone after the first call, so a repeat is refused (see each method), and `options.idempotencyKey`
+ * is sent nowhere for it. `append` takes one per attempt (made up when omitted, as
+ * `orders.drafts.place` does).
+ */
+import { errorFromGraphQLErrors, idempotencyKey as mintIdempotencyKey, pageFromVendureList, readOffsetCursor, ValidationError, } from '@sixtyninecommerce/core';
+/** The most fulfillments one `ship`, `deliver` or `pickList` call takes. */
+export const MAX_WAREHOUSE_BULK_IDS = 100;
+const ADDRESS_FIELDS = /* GraphQL */ `
+  fullName
+  company
+  streetLine1
+  streetLine2
+  city
+  province
+  postalCode
+  countryCode
+`;
+/**
+ * Every field of `WarehouseFulfillment` the workspace reads, without `lines`. A field list, never a
+ * named fragment: `orders-coverage.spec.ts` reads each document's root field with every
+ * interpolation replaced, which a fragment spread at the top level would not survive.
+ */
+export const FULFILLMENT_FIELDS = /* GraphQL */ `
+  id
+  state
+  handlerCode
+  method
+  mode
+  trackingCode
+  stockLocationId
+  stockLocationName
+  createdAt
+  stateChangedAt
+  overdue
+  claimedBy {
+    id
+    name
+  }
+  claimedAt
+  packedAt
+  bookingStatus
+  bookingError
+  parcels {
+    weightGrams
+    lengthMm
+    widthMm
+    heightMm
+  }
+  orders {
+    id
+    code
+    poNumber
+    orderNotes
+    requestedDeliveryDate
+    deliveryDue
+    paymentBadge
+    hold {
+      reason
+      note
+    }
+  }
+  customer {
+    id
+    name
+    phone
+  }
+  shippingAddress {
+    ${ADDRESS_FIELDS}
+  }
+  lineCount
+  unitCount
+`;
+/** Every field of `WarehouseDemandOrder`. */
+const DEMAND_ORDER_FIELDS = /* GraphQL */ `
+  orderId
+  orderCode
+  poNumber
+  orderNotes
+  requestedDeliveryDate
+  deliveryDue
+  orderPlacedAt
+  customer {
+    id
+    name
+    phone
+  }
+  shippingAddress {
+    ${ADDRESS_FIELDS}
+  }
+  consolidationKey
+  suggestedHandlerCode
+  paymentBadge
+  hold {
+    reason
+    note
+  }
+  queueExclusions
+  externalPlatform
+  externalOrderId
+  sourceFulfillmentHandedOff
+  sourceFulfilled
+  sourceFulfilledReason
+  chargedParcelCount
+  lines {
+    orderLineId
+    productVariantId
+    sku
+    name
+    featuredAsset {
+      id
+      preview
+    }
+    openQty
+    routing
+    routedLocationId
+    onHandAtLocation
+  }
+`;
+/** The `WarehouseError` member, read the same way under every union. */
+const ERROR_FIELDS = /* GraphQL */ `
+  ... on WarehouseError {
+    errorCode
+    code
+    message
+    field
+  }
+`;
+const SINGLE_RESULT = /* GraphQL */ `
+  __typename
+  ... on WarehouseFulfillment {
+    ${FULFILLMENT_FIELDS}
+  }
+  ${ERROR_FIELDS}
+`;
+const BULK_RESULT = /* GraphQL */ `
+  __typename
+  ... on WarehouseBulkResult {
+    succeeded
+    failed
+    results {
+      fulfillmentId
+      fulfillment {
+        ${FULFILLMENT_FIELDS}
+      }
+      error {
+        code
+        message
+        field
+      }
+    }
+  }
+  ${ERROR_FIELDS}
+`;
+// Each document is spelled out, root field included, so the coverage spec can read what it
+// reaches. The operation names are the dashboard's, so the audit trail reads as it always did.
+export const MY_WAREHOUSES_QUERY = /* GraphQL */ `
+  query MyWarehouses {
+    myWarehouses {
+      id
+      name
+    }
+  }
+`;
+export const WAREHOUSE_COUNTS_QUERY = /* GraphQL */ `
+  query WarehouseCounts($stockLocationId: ID!) {
+    warehouseCounts(stockLocationId: $stockLocationId) {
+      toShip
+      toPick
+      picking
+      packed
+      overdue
+      shippedToday
+      outsourced
+    }
+  }
+`;
+export const WAREHOUSE_DEMAND_QUERY = /* GraphQL */ `
+  query WarehouseDemand($input: WarehouseDemandInput!) {
+    warehouseDemand(input: $input) {
+      totalItems
+      truncated
+      items {
+        ${DEMAND_ORDER_FIELDS}
+      }
+    }
+  }
+`;
+export const WAREHOUSE_FULFILLMENTS_QUERY = /* GraphQL */ `
+  query WarehouseFulfillments($input: WarehouseFulfillmentListInput) {
+    warehouseFulfillments(input: $input) {
+      totalItems
+      items {
+        ${FULFILLMENT_FIELDS}
+      }
+    }
+  }
+`;
+export const WAREHOUSE_FULFILLMENT_QUERY = /* GraphQL */ `
+  query WarehouseFulfillment($id: ID!) {
+    warehouseFulfillment(id: $id) {
+      ${FULFILLMENT_FIELDS}
+      lines {
+        orderLineId
+        orderId
+        orderCode
+        productVariantId
+        sku
+        name
+        featuredAsset {
+          id
+          preview
+        }
+        quantity
+      }
+    }
+  }
+`;
+export const WAREHOUSE_FULFILLMENT_HANDLERS_QUERY = /* GraphQL */ `
+  query WarehouseFulfillmentHandlers {
+    warehouseFulfillmentHandlers {
+      code
+      description
+      mode
+      argsRequiredForCreate
+      args {
+        name
+        type
+        list
+        required
+        defaultValue
+        label
+        description
+        ui
+      }
+    }
+  }
+`;
+export const WAREHOUSE_PICK_LIST_QUERY = /* GraphQL */ `
+  query WarehousePickList($fulfillmentIds: [ID!]!) {
+    warehousePickList(fulfillmentIds: $fulfillmentIds) {
+      generatedAt
+      timeZone
+      warehouseNames
+      lineCount
+      unitCount
+      printedBy {
+        id
+        name
+      }
+      fulfillments {
+        id
+        reference
+        state
+        orderCodes
+        stockLocationName
+        lineCount
+        unitCount
+      }
+      lines {
+        sku
+        name
+        productVariantId
+        quantity
+        fulfillments {
+          fulfillmentId
+          reference
+          orderCodes
+          quantity
+        }
+      }
+    }
+  }
+`;
+export const WAREHOUSE_APPEND_CANDIDATES_QUERY = /* GraphQL */ `
+  query WarehouseAppendCandidates($fulfillmentId: ID!) {
+    warehouseAppendCandidates(fulfillmentId: $fulfillmentId) {
+      ${DEMAND_ORDER_FIELDS}
+    }
+  }
+`;
+/** The order API, not the warehouse one: it names money (`ReadOrder`). */
+export const FULFILLMENT_DETACH_PREVIEW_QUERY = /* GraphQL */ `
+  query FulfillmentDetachPreview($fulfillmentId: ID!, $orderId: ID!) {
+    fulfillmentDetachPreview(fulfillmentId: $fulfillmentId, orderId: $orderId) {
+      deliveryChargeApplies
+      profileName
+      profileMinimum
+      currencyCode
+      priceIncludesTax
+      currentIncludesTax
+      currentCharge
+      newCharge
+      orders {
+        orderId
+        code
+        currentCharge
+        newCharge
+      }
+      remainingNet
+      belowProfileMinimum
+      refusal {
+        code
+        message
+      }
+    }
+  }
+`;
+export const CLAIM_FULFILLMENT_MUTATION = /* GraphQL */ `
+  mutation ClaimFulfillment($id: ID!) {
+    claimFulfillment(id: $id) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const UNCLAIM_FULFILLMENT_MUTATION = /* GraphQL */ `
+  mutation UnclaimFulfillment($id: ID!) {
+    unclaimFulfillment(id: $id) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const REOPEN_FULFILLMENT_MUTATION = /* GraphQL */ `
+  mutation ReopenFulfillment($id: ID!) {
+    reopenFulfillment(id: $id) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const PACK_FULFILLMENT_MUTATION = /* GraphQL */ `
+  mutation PackFulfillment($id: ID!, $parcels: [WarehouseParcelInput!]) {
+    packFulfillment(id: $id, parcels: $parcels) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const BOOK_FULFILLMENT_MUTATION = /* GraphQL */ `
+  mutation BookFulfillment($id: ID!) {
+    bookFulfillment(id: $id) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const UNBOOK_FULFILLMENT_MUTATION = /* GraphQL */ `
+  mutation UnbookFulfillment($id: ID!) {
+    unbookFulfillment(id: $id) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const SET_FULFILLMENT_HANDLER_MUTATION = /* GraphQL */ `
+  mutation SetFulfillmentHandler(
+    $id: ID!
+    $handlerCode: String!
+    $handlerArgs: [WarehouseHandlerArgInput!]
+  ) {
+    setFulfillmentHandler(id: $id, handlerCode: $handlerCode, handlerArgs: $handlerArgs) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const SET_FULFILLMENT_WAREHOUSE_MUTATION = /* GraphQL */ `
+  mutation SetFulfillmentWarehouse($id: ID!, $stockLocationId: ID!) {
+    setFulfillmentWarehouse(id: $id, stockLocationId: $stockLocationId) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const CORRECT_FULFILLMENT_QUANTITIES_MUTATION = /* GraphQL */ `
+  mutation CorrectFulfillmentQuantities(
+    $fulfillmentId: ID!
+    $lines: [WarehouseQuantityCorrectionLineInput!]!
+    $disposition: FulfillmentUnitDisposition!
+    $reason: String
+  ) {
+    correctFulfillmentQuantities(
+      fulfillmentId: $fulfillmentId
+      lines: $lines
+      disposition: $disposition
+      reason: $reason
+    ) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const SHIP_FULFILLMENTS_MUTATION = /* GraphQL */ `
+  mutation ShipFulfillments($ids: [ID!]!, $trackingCode: String) {
+    shipFulfillments(ids: $ids, trackingCode: $trackingCode) {
+      ${BULK_RESULT}
+    }
+  }
+`;
+export const DELIVER_FULFILLMENTS_MUTATION = /* GraphQL */ `
+  mutation DeliverFulfillments($ids: [ID!]!) {
+    deliverFulfillments(ids: $ids) {
+      ${BULK_RESULT}
+    }
+  }
+`;
+export const APPEND_TO_FULFILLMENT_MUTATION = /* GraphQL */ `
+  mutation AppendToFulfillment(
+    $id: ID!
+    $lines: [WarehouseFulfillmentLineInput!]!
+    $idempotencyKey: String
+  ) {
+    appendToFulfillment(id: $id, lines: $lines, idempotencyKey: $idempotencyKey) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+export const DETACH_ORDER_FROM_FULFILLMENT_MUTATION = /* GraphQL */ `
+  mutation DetachOrderFromFulfillment($id: ID!, $orderId: ID!) {
+    detachOrderFromFulfillment(id: $id, orderId: $orderId) {
+      ${SINGLE_RESULT}
+    }
+  }
+`;
+// ── mapping ──────────────────────────────────────────────────────────────────
+/** The key a caller retries under, on an error of a call whose key it did not choose. */
+export function withAttemptKey(error, key) {
+    if (error !== null && typeof error === 'object' && !('idempotencyKey' in error)) {
+        Object.defineProperty(error, 'idempotencyKey', { value: key, enumerable: true });
+    }
+    return error;
+}
+export function isWarehouseErrorMember(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.__typename === 'WarehouseError');
+}
+/**
+ * A `WarehouseError` as the error the SAME code would be if a warehouse query had thrown it: the
+ * queries refuse with these codes as GraphQL errors, so classifying the union member by the
+ * ErrorResult rules would give one refusal two classes (`INVALID_INPUT` a 400 from a query and a
+ * 422 from a mutation).
+ *
+ * NOTE: every SDK method over a `WarehouseError` union classifies through this function, never
+ * through `errorFromErrorResult` (the create door, `createWarehouseFulfillments`, included).
+ * `fulfillments-warehouse.spec.ts` pins the class of every `WarehouseErrorCode`, so a change to
+ * core's GraphQL-dialect rules cannot move one silently.
+ */
+export function warehouseRefusalError(refusal) {
+    const field = typeof refusal.field === 'string' && refusal.field !== '' ? refusal.field : null;
+    return errorFromGraphQLErrors([
+        {
+            message: refusal.message,
+            extensions: {
+                code: refusal.code,
+                ...(field
+                    ? { details: [{ path: field, message: refusal.message, keyword: refusal.code }] }
+                    : {}),
+            },
+        },
+    ]);
+}
+export function invalid(field, message) {
+    return new ValidationError({
+        code: 'INVALID_INPUT',
+        message,
+        status: 400,
+        service: 'vendure',
+        details: [{ field, code: 'INVALID_INPUT', message }],
+    });
+}
+/** Refused before any request: an absent id would otherwise fail GraphQL validation, uncoded. */
+export function assertId(value, field) {
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw invalid(field, `A ${field} is required.`);
+    }
+}
+function assertIds(values, field) {
+    if (!Array.isArray(values) || values.length === 0) {
+        throw invalid(field, 'Name at least one fulfillment.');
+    }
+    for (const [index, value] of values.entries())
+        assertId(value, `${field}[${String(index)}]`);
+}
+function toAddress(raw) {
+    if (!raw)
+        return null;
+    return {
+        fullName: raw.fullName ?? null,
+        company: raw.company ?? null,
+        streetLine1: raw.streetLine1 ?? null,
+        streetLine2: raw.streetLine2 ?? null,
+        city: raw.city ?? null,
+        province: raw.province ?? null,
+        postalCode: raw.postalCode ?? null,
+        countryCode: raw.countryCode ?? null,
+    };
+}
+function toCustomer(raw) {
+    return raw ? { id: raw.id, name: raw.name ?? null, phone: raw.phone ?? null } : null;
+}
+function toHold(raw) {
+    return raw ? { reason: raw.reason ?? null, note: raw.note ?? null } : null;
+}
+function toAsset(raw) {
+    return raw ? { id: raw.id, preview: raw.preview } : null;
+}
+export function toFulfillment(raw) {
+    return {
+        id: raw.id,
+        state: raw.state,
+        handlerCode: raw.handlerCode,
+        method: raw.method ?? null,
+        mode: raw.mode,
+        trackingCode: raw.trackingCode ?? null,
+        stockLocationId: raw.stockLocationId ?? null,
+        stockLocationName: raw.stockLocationName ?? null,
+        createdAt: raw.createdAt,
+        stateChangedAt: raw.stateChangedAt ?? null,
+        overdue: raw.overdue,
+        claimedBy: raw.claimedBy ? { id: raw.claimedBy.id, name: raw.claimedBy.name ?? null } : null,
+        claimedAt: raw.claimedAt ?? null,
+        packedAt: raw.packedAt ?? null,
+        bookingStatus: raw.bookingStatus ?? null,
+        bookingError: raw.bookingError ?? null,
+        parcels: (raw.parcels ?? []).map((parcel) => ({
+            weightGrams: parcel.weightGrams,
+            lengthMm: parcel.lengthMm ?? null,
+            widthMm: parcel.widthMm ?? null,
+            heightMm: parcel.heightMm ?? null,
+        })),
+        orders: (raw.orders ?? []).map((order) => ({
+            id: order.id,
+            code: order.code,
+            poNumber: order.poNumber ?? null,
+            orderNotes: order.orderNotes ?? null,
+            requestedDeliveryDate: order.requestedDeliveryDate ?? null,
+            deliveryDue: order.deliveryDue ?? null,
+            paymentBadge: order.paymentBadge,
+            hold: toHold(order.hold),
+        })),
+        customer: toCustomer(raw.customer),
+        shippingAddress: toAddress(raw.shippingAddress),
+        lineCount: raw.lineCount,
+        unitCount: raw.unitCount,
+    };
+}
+function toDemandOrder(raw) {
+    return {
+        orderId: raw.orderId,
+        orderCode: raw.orderCode,
+        poNumber: raw.poNumber ?? null,
+        orderNotes: raw.orderNotes ?? null,
+        requestedDeliveryDate: raw.requestedDeliveryDate ?? null,
+        deliveryDue: raw.deliveryDue ?? null,
+        orderPlacedAt: raw.orderPlacedAt ?? null,
+        customer: toCustomer(raw.customer),
+        shippingAddress: toAddress(raw.shippingAddress),
+        consolidationKey: raw.consolidationKey ?? null,
+        suggestedHandlerCode: raw.suggestedHandlerCode ?? null,
+        paymentBadge: raw.paymentBadge,
+        hold: toHold(raw.hold),
+        queueExclusions: [...(raw.queueExclusions ?? [])],
+        externalPlatform: raw.externalPlatform ?? null,
+        externalOrderId: raw.externalOrderId ?? null,
+        sourceFulfillmentHandedOff: raw.sourceFulfillmentHandedOff ?? null,
+        sourceFulfilled: raw.sourceFulfilled === true,
+        sourceFulfilledReason: raw.sourceFulfilledReason ?? null,
+        chargedParcelCount: raw.chargedParcelCount ?? null,
+        lines: (raw.lines ?? []).map((line) => ({
+            orderLineId: line.orderLineId,
+            productVariantId: line.productVariantId,
+            sku: line.sku,
+            name: line.name,
+            featuredAsset: toAsset(line.featuredAsset),
+            openQty: line.openQty,
+            routing: line.routing,
+            routedLocationId: line.routedLocationId ?? null,
+            onHandAtLocation: line.onHandAtLocation ?? null,
+        })),
+    };
+}
+function toArg(raw) {
+    return {
+        name: raw.name,
+        type: raw.type,
+        list: raw.list,
+        required: raw.required,
+        defaultValue: raw.defaultValue ?? null,
+        label: raw.label ?? null,
+        description: raw.description ?? null,
+        ui: raw.ui ?? null,
+    };
+}
+export function toRefusal(raw) {
+    return raw ? { code: raw.code, message: raw.message, field: raw.field ?? null } : null;
+}
+/** The fulfillment a single-result write answers, or its refusal thrown coded. */
+function fulfillmentOrThrow(result) {
+    if (isWarehouseErrorMember(result))
+        throw warehouseRefusalError(result);
+    return toFulfillment(result);
+}
+function bulkOrThrow(result) {
+    if (isWarehouseErrorMember(result))
+        throw warehouseRefusalError(result);
+    const bulk = result;
+    return {
+        succeeded: bulk.succeeded,
+        failed: bulk.failed,
+        results: bulk.results.map((item) => ({
+            fulfillmentId: item.fulfillmentId,
+            fulfillment: item.fulfillment ? toFulfillment(item.fulfillment) : null,
+            error: toRefusal(item.error),
+        })),
+    };
+}
+const DEFAULT_TAKE = 50;
+export function createWarehouseFulfillmentsModule(transport) {
+    const single = async (query, field, variables, options) => {
+        const data = await transport.graphql({ api: 'admin', query, variables }, options);
+        return fulfillmentOrThrow(data[field]);
+    };
+    const demandPage = async (input, skip, options) => {
+        const take = input.take ?? DEFAULT_TAKE;
+        const data = await transport.graphql({
+            api: 'admin',
+            query: WAREHOUSE_DEMAND_QUERY,
+            variables: { input: { ...input, take, skip } },
+        }, options);
+        const page = pageFromVendureList({
+            items: data.warehouseDemand.items.map(toDemandOrder),
+            totalItems: data.warehouseDemand.totalItems,
+        }, skip, take, (cursor) => demandPage(input, readOffsetCursor(cursor), options));
+        return Object.assign(page, { truncated: data.warehouseDemand.truncated });
+    };
+    const listPage = async (input, skip, options) => {
+        const take = input.take ?? DEFAULT_TAKE;
+        const data = await transport.graphql({
+            api: 'admin',
+            query: WAREHOUSE_FULFILLMENTS_QUERY,
+            variables: { input: { ...input, take, skip } },
+        }, options);
+        return pageFromVendureList({
+            items: data.warehouseFulfillments.items.map(toFulfillment),
+            totalItems: data.warehouseFulfillments.totalItems,
+        }, skip, take, (cursor) => listPage(input, readOffsetCursor(cursor), options));
+    };
+    return {
+        async mine(options) {
+            const data = await transport.graphql({ api: 'admin', query: MY_WAREHOUSES_QUERY }, options);
+            return data.myWarehouses.map((location) => ({ id: location.id, name: location.name }));
+        },
+        async counts(stockLocationId, options) {
+            assertId(stockLocationId, 'stockLocationId');
+            const data = await transport.graphql({ api: 'admin', query: WAREHOUSE_COUNTS_QUERY, variables: { stockLocationId } }, options);
+            const counts = data.warehouseCounts;
+            return {
+                toShip: counts.toShip,
+                toPick: counts.toPick,
+                picking: counts.picking,
+                packed: counts.packed,
+                overdue: counts.overdue,
+                shippedToday: counts.shippedToday,
+                outsourced: counts.outsourced,
+            };
+        },
+        async demand(input, options) {
+            assertId(input?.stockLocationId, 'stockLocationId');
+            return demandPage(input, input.skip ?? 0, options);
+        },
+        async list(input = {}, options) {
+            return listPage(input, input.skip ?? 0, options);
+        },
+        async get(fulfillmentId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            const data = await transport.graphql({ api: 'admin', query: WAREHOUSE_FULFILLMENT_QUERY, variables: { id: fulfillmentId } }, options);
+            const raw = data.warehouseFulfillment;
+            return {
+                ...toFulfillment(raw),
+                lines: (raw.lines ?? []).map((line) => ({
+                    orderLineId: line.orderLineId,
+                    orderId: line.orderId,
+                    orderCode: line.orderCode,
+                    productVariantId: line.productVariantId,
+                    sku: line.sku,
+                    name: line.name,
+                    featuredAsset: toAsset(line.featuredAsset),
+                    quantity: line.quantity,
+                })),
+            };
+        },
+        async handlers(options) {
+            const data = await transport.graphql({ api: 'admin', query: WAREHOUSE_FULFILLMENT_HANDLERS_QUERY }, options);
+            return data.warehouseFulfillmentHandlers.map((handler) => ({
+                code: handler.code,
+                description: handler.description,
+                mode: handler.mode,
+                args: (handler.args ?? []).map(toArg),
+                argsRequiredForCreate: [...(handler.argsRequiredForCreate ?? [])],
+            }));
+        },
+        async pickList(fulfillmentIds, options) {
+            assertIds(fulfillmentIds, 'fulfillmentIds');
+            const data = await transport.graphql({ api: 'admin', query: WAREHOUSE_PICK_LIST_QUERY, variables: { fulfillmentIds } }, options);
+            const list = data.warehousePickList;
+            return {
+                generatedAt: list.generatedAt,
+                timeZone: list.timeZone,
+                warehouseNames: [...list.warehouseNames],
+                printedBy: list.printedBy
+                    ? { id: list.printedBy.id, name: list.printedBy.name ?? null }
+                    : null,
+                fulfillments: list.fulfillments.map((entry) => ({
+                    id: entry.id,
+                    reference: entry.reference,
+                    state: entry.state,
+                    orderCodes: [...entry.orderCodes],
+                    stockLocationName: entry.stockLocationName ?? null,
+                    lineCount: entry.lineCount,
+                    unitCount: entry.unitCount,
+                })),
+                lines: list.lines.map((line) => ({
+                    sku: line.sku,
+                    name: line.name,
+                    productVariantId: line.productVariantId,
+                    quantity: line.quantity,
+                    fulfillments: line.fulfillments.map((part) => ({
+                        fulfillmentId: part.fulfillmentId,
+                        reference: part.reference,
+                        orderCodes: [...part.orderCodes],
+                        quantity: part.quantity,
+                    })),
+                })),
+                lineCount: list.lineCount,
+                unitCount: list.unitCount,
+            };
+        },
+        async appendCandidates(fulfillmentId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            const data = await transport.graphql({ api: 'admin', query: WAREHOUSE_APPEND_CANDIDATES_QUERY, variables: { fulfillmentId } }, options);
+            return data.warehouseAppendCandidates.map(toDemandOrder);
+        },
+        async detachPreview(fulfillmentId, orderId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            assertId(orderId, 'orderId');
+            const data = await transport.graphql({
+                api: 'admin',
+                query: FULFILLMENT_DETACH_PREVIEW_QUERY,
+                variables: { fulfillmentId, orderId },
+            }, options);
+            const preview = data.fulfillmentDetachPreview;
+            return {
+                deliveryChargeApplies: preview.deliveryChargeApplies,
+                profileName: preview.profileName ?? null,
+                profileMinimum: preview.profileMinimum,
+                currencyCode: preview.currencyCode,
+                priceIncludesTax: preview.priceIncludesTax,
+                currentIncludesTax: preview.currentIncludesTax,
+                currentCharge: preview.currentCharge,
+                newCharge: preview.newCharge,
+                orders: preview.orders.map((order) => ({
+                    orderId: order.orderId,
+                    code: order.code,
+                    currentCharge: order.currentCharge,
+                    newCharge: order.newCharge,
+                })),
+                remainingNet: preview.remainingNet,
+                belowProfileMinimum: preview.belowProfileMinimum,
+                refusal: preview.refusal
+                    ? { code: preview.refusal.code, message: preview.refusal.message }
+                    : null,
+            };
+        },
+        async claim(fulfillmentId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            return single(CLAIM_FULFILLMENT_MUTATION, 'claimFulfillment', { id: fulfillmentId }, options);
+        },
+        async unclaim(fulfillmentId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            return single(UNCLAIM_FULFILLMENT_MUTATION, 'unclaimFulfillment', { id: fulfillmentId }, options);
+        },
+        async reopen(fulfillmentId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            return single(REOPEN_FULFILLMENT_MUTATION, 'reopenFulfillment', { id: fulfillmentId }, options);
+        },
+        async pack(fulfillmentId, input = {}, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            const parcels = input.parcels;
+            return single(PACK_FULFILLMENT_MUTATION, 'packFulfillment', {
+                id: fulfillmentId,
+                // Omitted is null; an empty list is sent as it is, and the engine refuses it.
+                parcels: parcels
+                    ? parcels.map((parcel) => ({
+                        weightGrams: parcel.weightGrams,
+                        ...(parcel.lengthMm === undefined ? {} : { lengthMm: parcel.lengthMm }),
+                        ...(parcel.widthMm === undefined ? {} : { widthMm: parcel.widthMm }),
+                        ...(parcel.heightMm === undefined ? {} : { heightMm: parcel.heightMm }),
+                    }))
+                    : null,
+            }, options);
+        },
+        async book(fulfillmentId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            return single(BOOK_FULFILLMENT_MUTATION, 'bookFulfillment', { id: fulfillmentId }, options);
+        },
+        async unbook(fulfillmentId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            return single(UNBOOK_FULFILLMENT_MUTATION, 'unbookFulfillment', { id: fulfillmentId }, options);
+        },
+        async setHandler(fulfillmentId, handlerCode, handlerArgs = [], options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            assertId(handlerCode, 'handlerCode');
+            return single(SET_FULFILLMENT_HANDLER_MUTATION, 'setFulfillmentHandler', {
+                id: fulfillmentId,
+                handlerCode,
+                handlerArgs: handlerArgs.map(({ name, value }) => ({ name, value })),
+            }, options);
+        },
+        async setWarehouse(fulfillmentId, stockLocationId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            assertId(stockLocationId, 'stockLocationId');
+            return single(SET_FULFILLMENT_WAREHOUSE_MUTATION, 'setFulfillmentWarehouse', { id: fulfillmentId, stockLocationId }, options);
+        },
+        async correct(fulfillmentId, input, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            const reason = input.reason?.trim();
+            return single(CORRECT_FULFILLMENT_QUANTITIES_MUTATION, 'correctFulfillmentQuantities', {
+                fulfillmentId,
+                lines: input.lines.map((line) => ({
+                    orderLineId: line.orderLineId,
+                    quantity: line.quantity,
+                    ...(line.reduceOrderLine === undefined
+                        ? {}
+                        : { reduceOrderLine: line.reduceOrderLine }),
+                })),
+                disposition: input.disposition,
+                reason: reason ? reason : null,
+            }, options);
+        },
+        async ship(fulfillmentIds, trackingCode, options) {
+            assertIds(fulfillmentIds, 'fulfillmentIds');
+            const tracking = trackingCode?.trim();
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SHIP_FULFILLMENTS_MUTATION,
+                variables: { ids: fulfillmentIds, trackingCode: tracking ? tracking : null },
+            }, options);
+            return bulkOrThrow(data.shipFulfillments);
+        },
+        async deliver(fulfillmentIds, options) {
+            assertIds(fulfillmentIds, 'fulfillmentIds');
+            const data = await transport.graphql({ api: 'admin', query: DELIVER_FULFILLMENTS_MUTATION, variables: { ids: fulfillmentIds } }, options);
+            return bulkOrThrow(data.deliverFulfillments);
+        },
+        async append(fulfillmentId, lines, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            const key = options?.idempotencyKey ?? mintIdempotencyKey();
+            try {
+                const fulfillment = await single(APPEND_TO_FULFILLMENT_MUTATION, 'appendToFulfillment', {
+                    id: fulfillmentId,
+                    lines: lines.map(({ orderLineId, quantity }) => ({ orderLineId, quantity })),
+                    idempotencyKey: key,
+                }, { ...options, idempotencyKey: key });
+                return { ...fulfillment, idempotencyKey: key };
+            }
+            catch (error) {
+                throw withAttemptKey(error, key);
+            }
+        },
+        async detach(fulfillmentId, orderId, options) {
+            assertId(fulfillmentId, 'fulfillmentId');
+            assertId(orderId, 'orderId');
+            return single(DETACH_ORDER_FROM_FULFILLMENT_MUTATION, 'detachOrderFromFulfillment', { id: fulfillmentId, orderId }, options);
+        },
+    };
+}