@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/orders/order-entry.js

@@ -0,0 +1,129 @@
+/**
+ * Everything the caller was promised about the composed order, in one
+ * projection: every line with its ids, both bases of its prices and its tax
+ * lines, the order's own totals, its surcharges, and the ref it was filed under.
+ *
+ * Deliberately generous. The whole point of an atomic compose is that the caller
+ * never has to ask a second question to learn what it got, and a retry that had
+ * to re-read the order to find its line ids would defeat it.
+ */
+const EXTERNAL_ORDER_FIELDS = /* GraphQL */ `
+  id
+  code
+  state
+  currencyCode
+  subTotal
+  subTotalWithTax
+  total
+  totalWithTax
+  lines {
+    id
+    quantity
+    unitPrice
+    unitPriceWithTax
+    linePrice
+    linePriceWithTax
+    taxLines {
+      description
+      taxRate
+    }
+    productVariant {
+      id
+      sku
+      name
+    }
+    customFields {
+      externalEntryPosition
+      externalEntryKey
+      externalLineLabel
+    }
+  }
+  surcharges {
+    id
+    description
+    sku
+    price
+    priceWithTax
+    taxRate
+  }
+  customFields {
+    externalRef
+  }
+`;
+export const CREATE_OR_RECOVER_ORDER_MUTATION = /* GraphQL */ `
+  mutation CreateOrRecoverOrder($input: ExternalOrderInput!, $idempotencyKey: String!) {
+    createOrRecoverOrder(input: $input, idempotencyKey: $idempotencyKey) {
+      ${EXTERNAL_ORDER_FIELDS}
+    }
+  }
+`;
+export const ORDER_BY_EXTERNAL_REF_QUERY = /* GraphQL */ `
+  query OrderByExternalRef($externalRef: String!) {
+    orderByExternalRef(externalRef: $externalRef) {
+      ${EXTERNAL_ORDER_FIELDS}
+    }
+  }
+`;
+export const ORDER_BY_IDEMPOTENCY_KEY_QUERY = /* GraphQL */ `
+  query OrderByIdempotencyKey($key: String!) {
+    orderByIdempotencyKey(key: $key) {
+      ${EXTERNAL_ORDER_FIELDS}
+    }
+  }
+`;
+/**
+ * The SDK's discriminated line → the wrapper member the SDL declares.
+ *
+ * `kind` is stripped rather than sent: it is not a field of either input type,
+ * and the Admin API runs `forbidNonWhitelisted`-equivalent GraphQL input
+ * coercion, so leaving it on would 400 the whole document.
+ *
+ * Every other key is copied ACROSS, never rebuilt field by field: `configuration`
+ * is the caller's own JSON and must reach the engine byte-for-byte, and a
+ * hand-written field list would also silently drop a field added to the input
+ * type later. Nothing on this path converts case — see
+ * {@link ExternalOrderExternalLine.configuration}.
+ *
+ * An absent optional stays ABSENT rather than becoming an explicit null:
+ * `JSON.stringify` drops `undefined`, and the engine's request fingerprint is
+ * taken from the raw wire arguments, so coercing one to null here would make two
+ * identical requests look different to the idempotency store.
+ */
+export function toWireLine(line) {
+    const { kind, ...rest } = line;
+    return kind === 'catalog'
+        ? { catalog: rest }
+        : { external: rest };
+}
+/** The input as the engine declares it, lines wrapped. */
+function toWireInput(input) {
+    return { ...input, lines: (input.lines ?? []).map(toWireLine) };
+}
+export function createOrderEntryModule(transport) {
+    return {
+        async createOrRecover(input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: CREATE_OR_RECOVER_ORDER_MUTATION,
+                // The key travels as an ARGUMENT, not as the `Idempotency-Key` header
+                // the transport would otherwise send: the Admin API has no header for
+                // it, and `options` is forwarded separately so the header goes out too
+                // for any middleware that records it.
+                variables: { input: toWireInput(input), idempotencyKey: options.idempotencyKey },
+            }, options);
+            return data.createOrRecoverOrder;
+        },
+        async byExternalRef(externalRef, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_BY_EXTERNAL_REF_QUERY, variables: { externalRef } }, options);
+            // `?? null`, not the raw value: a field the engine answers as absent
+            // rather than null would otherwise reach the caller as `undefined`, and
+            // `order === null` is how every consumer of this method asks "is there
+            // one?".
+            return data.orderByExternalRef ?? null;
+        },
+        async byIdempotencyKey(key, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_BY_IDEMPOTENCY_KEY_QUERY, variables: { key } }, options);
+            return data.orderByIdempotencyKey ?? null;
+        },
+    };
+}

package/dist/orders/parcel-charge.d.ts

@@ -0,0 +1,45 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** One fulfilment of the order, as far as its parcels go. */
+export interface OrderParcelChargeFulfillment {
+    id: string;
+    state: string;
+    /** Parcels the warehouse pack step recorded on it; 0 when none were. */
+    parcelCount: number;
+    /**
+     * Every order this fulfilment ships in the channel, this one included. A
+     * fulfilment can ship several orders of one customer, so its parcels are
+     * then shared with orders whose charge this read does not return.
+     */
+    orderIds: string[];
+    /** The order lines it ships, which may include another order's lines. */
+    orderLineIds: string[];
+}
+/** What an order's shipping was charged for, next to what its fulfilments packed. */
+export interface OrderParcelCharge {
+    orderId: string;
+    /**
+     * The parcel count the shipping price was charged for, frozen when the order
+     * left the cart. `null` when the order was not priced per parcel.
+     */
+    chargedParcelCount: number | null;
+    /** This order's own line ids, to tell its lines from another order's in a fulfilment. */
+    lineIds: string[];
+    fulfillments: OrderParcelChargeFulfillment[];
+}
+/**
+ * Its own document on purpose: `chargedParcelCount` exists only on an engine
+ * with the extra-parcel charge, so on an older one this call alone fails
+ * validation and no other order read does.
+ */
+export declare const ORDER_PARCEL_CHARGE_QUERY = "\n  query OrderParcelCharge($id: ID!) {\n    order(id: $id) {\n      id\n      customFields {\n        chargedParcelCount\n      }\n      lines {\n        id\n      }\n      fulfillments {\n        id\n        state\n        lines {\n          orderLineId\n        }\n        linkedOrders {\n          id\n        }\n        customFields {\n          parcels {\n            weightGrams\n          }\n        }\n      }\n    }\n  }\n";
+export interface OrderParcelChargeModule {
+    /**
+     * The parcel count an order was charged for and the parcels its fulfilments
+     * recorded. `null` when the order does not exist in this channel. Needs
+     * `ReadOrder`, and an engine that serves
+     * `Order.customFields.chargedParcelCount`.
+     */
+    parcelCharge(orderId: string, options?: Call): Promise<OrderParcelCharge | null>;
+}
+export declare function createOrderParcelChargeModule(transport: Transport): OrderParcelChargeModule;

package/dist/orders/parcel-charge.js

@@ -0,0 +1,55 @@
+/**
+ * Its own document on purpose: `chargedParcelCount` exists only on an engine
+ * with the extra-parcel charge, so on an older one this call alone fails
+ * validation and no other order read does.
+ */
+export const ORDER_PARCEL_CHARGE_QUERY = /* GraphQL */ `
+  query OrderParcelCharge($id: ID!) {
+    order(id: $id) {
+      id
+      customFields {
+        chargedParcelCount
+      }
+      lines {
+        id
+      }
+      fulfillments {
+        id
+        state
+        lines {
+          orderLineId
+        }
+        linkedOrders {
+          id
+        }
+        customFields {
+          parcels {
+            weightGrams
+          }
+        }
+      }
+    }
+  }
+`;
+function toParcelCharge(order) {
+    return {
+        orderId: order.id,
+        chargedParcelCount: order.customFields?.chargedParcelCount ?? null,
+        lineIds: order.lines.map((line) => line.id),
+        fulfillments: (order.fulfillments ?? []).map((fulfillment) => ({
+            id: fulfillment.id,
+            state: fulfillment.state,
+            parcelCount: fulfillment.customFields?.parcels?.length ?? 0,
+            orderIds: fulfillment.linkedOrders.map((linked) => linked.id),
+            orderLineIds: fulfillment.lines.map((line) => line.orderLineId),
+        })),
+    };
+}
+export function createOrderParcelChargeModule(transport) {
+    return {
+        async parcelCharge(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_PARCEL_CHARGE_QUERY, variables: { id: orderId } }, options);
+            return data.order ? toParcelCharge(data.order) : null;
+        },
+    };
+}