@sixtyninecommerce/admin 0.11.0 → 0.12.0

package/dist/integrations/exact-online.js

@@ -1,5 +1,8 @@
-import { ValidationError } from '@sixtyninecommerce/core';
+import { createPage, PLATFORM_PASSTHROUGH_KEYS, readRestPage, ValidationError, } from '@sixtyninecommerce/core';
 import { fieldOf } from '../catalog/types.js';
+import { isUnknownFieldRejection } from '../payments/store-credit-fields.js';
+/** The most sync-log rows one {@link ExactOnlineSyncModule.logs} read answers. */
+export const EXACT_ONLINE_SYNC_LOG_LIMIT = 100;
 const SYNC_WINDOW_FIELDS = /* GraphQL */ `enabled intervalMinutes`;
 const CONFIG_FIELDS = /* GraphQL */ `
   id
@@ -280,6 +283,487 @@ export const EXACT_ONLINE_SYNC_ESTIMATE_QUERY = /* GraphQL */ `
     }
   }
 `;
+const SYNC_LOG_FIELDS = /* GraphQL */ `
+  id
+  entity
+  mode
+  status
+  createdCount
+  updatedCount
+  skippedCount
+  failedCount
+  detachedCount
+  error
+  durationMs
+  createdAt
+  catalogueExclusions { inactive notWebshop nonStock unpriced total absent }
+`;
+export const EXACT_ONLINE_SYNC_LOGS_QUERY = /* GraphQL */ `
+  query ExactOnlineSyncLogs($limit: Int, $entity: String) {
+    exactOnlineSyncLogs(limit: $limit, entity: $entity) { ${SYNC_LOG_FIELDS} }
+  }
+`;
+const RUN_SUMMARY_FIELDS = /* GraphQL */ `lastRunAt status error lastSuccessAt`;
+export const EXACT_ONLINE_SYNC_HEALTH_QUERY = /* GraphQL */ `
+  query ExactOnlineSyncHealth {
+    exactOnlineSyncHealth {
+      customers { ${RUN_SUMMARY_FIELDS} }
+      catalogue { ${RUN_SUMMARY_FIELDS} }
+      orders { ${RUN_SUMMARY_FIELDS} }
+    }
+  }
+`;
+export const RUN_EXACT_ONLINE_CATALOGUE_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineCatalogueSync {
+    runExactOnlineCatalogueSync
+  }
+`;
+export const RUN_EXACT_ONLINE_CUSTOMER_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineCustomerSync {
+    runExactOnlineCustomerSync
+  }
+`;
+export const RUN_EXACT_ONLINE_PRICE_LIST_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlinePriceListSync {
+    runExactOnlinePriceListSync
+  }
+`;
+export const REIMPORT_EXACT_ONLINE_ITEM_PICTURES_MUTATION = /* GraphQL */ `
+  mutation ReimportExactOnlineItemPictures {
+    reimportExactOnlineItemPictures
+  }
+`;
+export const EXACT_ONLINE_SYNC_CURSORS_QUERY = /* GraphQL */ `
+  query ExactOnlineSyncCursors {
+    exactOnlineSyncCursors { entity cursor }
+  }
+`;
+export const RESET_EXACT_ONLINE_SYNC_CURSOR_MUTATION = /* GraphQL */ `
+  mutation ResetExactOnlineSyncCursor($entity: String!) {
+    resetExactOnlineSyncCursor(entity: $entity)
+  }
+`;
+export const EXACT_ONLINE_WAREHOUSE_LINKS_QUERY = /* GraphQL */ `
+  query ExactOnlineWarehouseLinks {
+    exactOnlineWarehouseLinks { stockLocationId stockLocationName exactWarehouseId }
+  }
+`;
+const SHIPPING_MAPPING_FIELDS = /* GraphQL */ `
+  vendureShippingMethodId
+  vendureCode
+  vendureName
+  exactShippingMethodId
+  exactManaged
+  status
+`;
+export const EXACT_ONLINE_SHIPPING_METHODS_QUERY = /* GraphQL */ `
+  query ExactOnlineShippingMethods {
+    exactOnlineShippingMethods {
+      mappings { ${SHIPPING_MAPPING_FIELDS} }
+      exact { id code description active amount linked }
+    }
+  }
+`;
+export const RUN_EXACT_ONLINE_SHIPPING_METHOD_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineShippingMethodSync {
+    runExactOnlineShippingMethodSync
+  }
+`;
+export const IMPORT_EXACT_ONLINE_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation ImportExactOnlineShippingMethod($exactShippingMethodId: String!) {
+    importExactOnlineShippingMethod(exactShippingMethodId: $exactShippingMethodId) {
+      ${SHIPPING_MAPPING_FIELDS}
+    }
+  }
+`;
+export const SET_EXACT_ONLINE_SHIPPING_METHOD_MAPPING_MUTATION = /* GraphQL */ `
+  mutation SetExactOnlineShippingMethodMapping(
+    $vendureShippingMethodId: ID!
+    $exactShippingMethodId: String
+  ) {
+    setExactOnlineShippingMethodMapping(
+      vendureShippingMethodId: $vendureShippingMethodId
+      exactShippingMethodId: $exactShippingMethodId
+    ) {
+      ${SHIPPING_MAPPING_FIELDS}
+    }
+  }
+`;
+export const CONVERT_EXACT_ONLINE_SHIPPING_METHOD_TO_MAPPING_MUTATION = /* GraphQL */ `
+  mutation ConvertExactOnlineShippingMethodToMapping(
+    $exactShippingMethodId: String!
+    $vendureShippingMethodId: ID!
+  ) {
+    convertExactOnlineShippingMethodToMapping(
+      exactShippingMethodId: $exactShippingMethodId
+      vendureShippingMethodId: $vendureShippingMethodId
+    ) {
+      ${SHIPPING_MAPPING_FIELDS}
+    }
+  }
+`;
+export const RETIRE_EXACT_ONLINE_IMPORTED_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation RetireExactOnlineImportedShippingMethod($exactShippingMethodId: String!) {
+    retireExactOnlineImportedShippingMethod(exactShippingMethodId: $exactShippingMethodId)
+  }
+`;
+// ── Payment and delivery terms (W10-57) ──
+const PAYMENT_CONDITION_DISTRIBUTION_FIELDS = /* GraphQL */ `code description customerCount`;
+const UNRESOLVED_PAYMENT_CONDITION_FIELDS = /* GraphQL */ `code customerCount`;
+const DRY_RUN_RESOURCE_FIELDS = /* GraphQL */ `resource ok permissionWarning error`;
+export const EXACT_ONLINE_PAYMENT_CONDITIONS_QUERY = /* GraphQL */ `
+  query ExactOnlinePaymentConditions {
+    exactOnlinePaymentConditions {
+      exactId
+      code
+      description
+      summary
+      classification
+      paymentDays
+      paymentEndOfMonths
+      paymentMethod
+      percentage
+      discountPaymentDays
+      discountPercentage
+      paymentDiscountType
+      active
+      syncedAt
+    }
+  }
+`;
+export const EXACT_ONLINE_PAYMENT_TERMS_DIAGNOSTICS_QUERY = /* GraphQL */ `
+  query ExactOnlinePaymentTermsDiagnostics {
+    exactOnlinePaymentTermsDiagnostics {
+      totalCustomers
+      assignedCount
+      unassignedCount
+      unresolvedCount
+      staleCount
+      lastSyncedAt
+      error
+      permissionWarning
+      distribution { ${PAYMENT_CONDITION_DISTRIBUTION_FIELDS} }
+      unresolvedCodes { ${UNRESOLVED_PAYMENT_CONDITION_FIELDS} }
+      lastReconciliation {
+        mode
+        status
+        createdCount
+        updatedCount
+        deactivatedCount
+        failedCount
+        at
+        error
+      }
+    }
+  }
+`;
+const DRY_RUN_CONDITION_FIELDS = /* GraphQL */ `code description summary classification scheduleCount`;
+export const EXACT_ONLINE_PAYMENT_TERMS_DRY_RUN_QUERY = /* GraphQL */ `
+  query ExactOnlinePaymentTermsDryRun {
+    exactOnlinePaymentTermsDryRun {
+      division
+      generatedAt
+      complete
+      permissionWarning
+      catalogRowCount
+      catalogCodeCount
+      accountCount
+      assignedCount
+      unassignedCount
+      unresolvedCount
+      uncheckedCount
+      distribution { ${PAYMENT_CONDITION_DISTRIBUTION_FIELDS} }
+      duplicateConditions { ${DRY_RUN_CONDITION_FIELDS} }
+      complexConditions { ${DRY_RUN_CONDITION_FIELDS} }
+      unresolvedCodes { ${UNRESOLVED_PAYMENT_CONDITION_FIELDS} }
+      assignmentIssues { accountId accountCode conditionCode conditionDescription status }
+      resources { ${DRY_RUN_RESOURCE_FIELDS} }
+    }
+  }
+`;
+export const EXACT_ONLINE_INCOTERMS_QUERY = /* GraphQL */ `
+  query ExactOnlineIncoterms {
+    exactOnlineIncoterms {
+      exactId
+      code
+      version
+      description
+      catalogAvailable
+      stale
+      lastSyncedAt
+      error
+    }
+  }
+`;
+export const EXACT_ONLINE_DELIVERY_TERMS_DIAGNOSTICS_QUERY = /* GraphQL */ `
+  query ExactOnlineDeliveryTermsDiagnostics {
+    exactOnlineDeliveryTermsDiagnostics {
+      reconciliationRequired
+      accountSyncStatus
+      totalCustomers
+      assignedCount
+      unassignedCount
+      unresolvedCount
+      staleCount
+      mappedMethodCount
+      usableShippingMappingCount
+      unmappedMethodCount
+      inactiveMethodCount
+      unavailableMethodCount
+      nullAmountCount
+      invalidIncotermCount
+      lastSyncedAt
+      error
+      permissionWarning
+      shippingMethodDistribution { exactId code description customerCount }
+      incotermDistribution { code version description customerCount }
+      warnings
+    }
+  }
+`;
+export const EXACT_ONLINE_DELIVERY_TERMS_DRY_RUN_QUERY = /* GraphQL */ `
+  query ExactOnlineDeliveryTermsDryRun {
+    exactOnlineDeliveryTermsDryRun {
+      division
+      generatedAt
+      complete
+      permissionWarning
+      shippingMethodCount
+      activeShippingMethodCount
+      mappingCount
+      unmappedCatalogMethodCount
+      nullAmountCount
+      zeroAmountCount
+      incotermCount
+      accountCount
+      assignedShippingMethodCount
+      mappedAssignedShippingMethodCount
+      unmappedAssignedShippingMethodCount
+      unassignedShippingMethodCount
+      unresolvedShippingMethodCount
+      assignedIncotermCount
+      unassignedIncotermCount
+      unresolvedIncotermCount
+      invalidPolicyCount
+      shippingMethodDistribution { exactId customerCount }
+      incotermDistribution { code version customerCount }
+      assignmentIssues {
+        accountId
+        accountCode
+        shippingMethodId
+        incotermCode
+        incotermVersion
+        status
+        message
+      }
+      resources { ${DRY_RUN_RESOURCE_FIELDS} }
+    }
+  }
+`;
+// ── The customer, order and product cards (W10-57) ──
+export const EXACT_ONLINE_CUSTOMER_PAYMENT_TERMS_QUERY = /* GraphQL */ `
+  query ExactOnlineCustomerPaymentTerms($customerId: ID!) {
+    exactOnlineCustomerPaymentTerms(customerId: $customerId) {
+      customerId
+      source
+      managedExternally
+      linkedExternally
+      status
+      stale
+      exactAccountId
+      exactAccountCode
+      conditionCode
+      conditionDescription
+      summary
+      classification
+      paymentDays
+      paymentEndOfMonths
+      paymentMethod
+      percentage
+      discountPaymentDays
+      discountPercentage
+      paymentDiscountType
+      syncedAt
+      lastCheckedAt
+      error
+    }
+  }
+`;
+export const EXACT_ONLINE_CUSTOMER_DELIVERY_TERMS_QUERY = /* GraphQL */ `
+  query ExactOnlineCustomerDeliveryTerms($customerId: ID!) {
+    exactOnlineCustomerDeliveryTerms(customerId: $customerId) {
+      customerId
+      source
+      managedExternally
+      linkedExternally
+      status
+      shippingMethodStatus
+      policyStatus
+      summary
+      exactAccountId
+      exactAccountCode
+      preferredShippingMethodId
+      preferredShippingMethodCode
+      preferredShippingMethodName
+      preferredShippingMethodAvailable
+      eligibleShippingMethodIds
+      incotermStatus
+      incotermCode
+      incotermVersion
+      incotermAddress
+      incotermDescription
+      shippingLeadDays
+      deliveryAdvice
+      stale
+      syncedAt
+      lastCheckedAt
+      error
+    }
+  }
+`;
+export const EXACT_ONLINE_CUSTOMER_PRICE_LIST_QUERY = /* GraphQL */ `
+  query ExactOnlineCustomerPriceList($customerId: ID!) {
+    exactOnlineCustomerPriceList(customerId: $customerId) {
+      customerId
+      exactAccountId
+      exactAccountCode
+      exactPriceListId
+      groupId
+      groupName
+      priceListId
+      priceListName
+      status
+      lastReconciledAt
+      lastError
+    }
+  }
+`;
+export const EXACT_ONLINE_ORDER_STATE_QUERY = /* GraphQL */ `
+  query ExactOnlineOrderState($orderId: ID!) {
+    exactOnlineOrderState(orderId: $orderId) {
+      pushed
+      origin
+      salesOrderId
+      salesOrderNumber
+      pushedAt
+      hasCustomer
+      customerLinked
+      unmappedSkus
+      warnings
+    }
+  }
+`;
+export const EXACT_ONLINE_ORDER_SYNC_STATE_QUERY = /* GraphQL */ `
+  query ExactOnlineOrderSyncState($orderId: ID!) {
+    exactOnlineOrderSyncState(orderId: $orderId) {
+      exactSalesOrderId
+      exactOrderNumber
+      revision
+      lastSyncedAt
+      driftDetected
+      exactDeletedAt
+      unmappedSkus
+    }
+  }
+`;
+export const PUSH_ORDER_TO_EXACT_ONLINE_MUTATION = /* GraphQL */ `
+  mutation PushOrderToExactOnline($orderId: ID!) {
+    pushOrderToExactOnline(orderId: $orderId) {
+      success
+      alreadyPushed
+      salesOrderId
+      salesOrderNumber
+      error
+      errorCode
+      warnings
+    }
+  }
+`;
+/**
+ * {@link EXACT_ONLINE_ORDER_STATE_QUERY} without `warnings`, for an engine that predates the field
+ * (#1925): services deploy separately, and GraphQL refuses the whole document over one unknown
+ * field. Drop it once every engine serves `warnings` (orchestrator probe 2026-10-16: production
+ * did not yet).
+ */
+export const EXACT_ONLINE_ORDER_STATE_LEGACY_QUERY = /* GraphQL */ `
+  query ExactOnlineOrderState($orderId: ID!) {
+    exactOnlineOrderState(orderId: $orderId) {
+      pushed
+      origin
+      salesOrderId
+      salesOrderNumber
+      pushedAt
+      hasCustomer
+      customerLinked
+      unmappedSkus
+    }
+  }
+`;
+/**
+ * {@link PUSH_ORDER_TO_EXACT_ONLINE_MUTATION} without `warnings`, for an engine that predates the
+ * field. Safe to send after the current document was refused: an unknown field fails validation,
+ * before the push runs, so nothing reached Exact. Drop it with the state read's.
+ */
+export const PUSH_ORDER_TO_EXACT_ONLINE_LEGACY_MUTATION = /* GraphQL */ `
+  mutation PushOrderToExactOnline($orderId: ID!) {
+    pushOrderToExactOnline(orderId: $orderId) {
+      success
+      alreadyPushed
+      salesOrderId
+      salesOrderNumber
+      error
+      errorCode
+    }
+  }
+`;
+export const REPRICE_EXACT_ONLINE_ORDER_MUTATION = /* GraphQL */ `
+  mutation RepriceExactOnlineOrder($orderId: ID!) {
+    repriceExactOnlineOrder(orderId: $orderId) {
+      success
+      changed
+      linesRepriced
+      error
+    }
+  }
+`;
+export const REPRICE_ALL_EXACT_ONLINE_IMPORTED_ORDERS_MUTATION = /* GraphQL */ `
+  mutation RepriceAllExactOnlineImportedOrders {
+    repriceAllExactOnlineImportedOrders {
+      total
+      repriced
+      skipped
+      failed
+    }
+  }
+`;
+export const RUN_EXACT_ONLINE_ORDER_SYNC_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineOrderSync {
+    runExactOnlineOrderSync
+  }
+`;
+export const RUN_EXACT_ONLINE_ORDER_BACKFILL_MUTATION = /* GraphQL */ `
+  mutation RunExactOnlineOrderBackfill {
+    runExactOnlineOrderBackfill
+  }
+`;
+export const EXACT_PRODUCT_STATUS_QUERY = /* GraphQL */ `
+  query ExactProductStatus($id: ID!) {
+    product(id: $id) {
+      id
+      customFields {
+        exactManaged
+        exactItemId
+        exactItemGroupId
+        exactDisabledReason
+      }
+    }
+  }
+`;
+/** The plugins service's Exact connection-log routes (force-scoped to the caller's store). */
+const CONNECTION_LOGS = '/exact-online/logs';
+/** How long a connection-log export may stream before the call gives up, unless said otherwise. */
+export const EXACT_ONLINE_LOG_EXPORT_TIMEOUT_MS = 120_000;
+const CONNECTION_LOG_KINDS = ['calls', 'events'];
 const invalidInput = (message, field) => new ValidationError({
     code: 'INVALID_EXACT_ONLINE_INPUT',
     message,
@@ -312,8 +796,74 @@ function configVariables(input) {
     }
     return variables;
 }
+/** A sync-log read's variables: only what was given, after the checks the engine would skip. */
+function syncLogVariables(options) {
+    const { entity, limit } = options;
+    if (limit !== undefined &&
+        (!Number.isInteger(limit) || limit < 1 || limit > EXACT_ONLINE_SYNC_LOG_LIMIT)) {
+        throw invalidInput(`limit must be a whole number from 1 to ${String(EXACT_ONLINE_SYNC_LOG_LIMIT)}.`, 'limit');
+    }
+    if (entity !== undefined && (typeof entity !== 'string' || entity.trim() === '')) {
+        throw invalidInput('entity must name a sync entity, such as "items".', 'entity');
+    }
+    return {
+        ...(limit === undefined ? {} : { limit }),
+        ...(entity === undefined ? {} : { entity }),
+    };
+}
+/** An id the call is about, refused before sending when it is not a non-blank string. */
+function requireId(id, field, method) {
+    if (typeof id !== 'string' || id.trim() === '') {
+        throw invalidInput(`${method} needs the ${field}.`, field);
+    }
+    return id;
+}
+function requireEntity(entity) {
+    if (typeof entity !== 'string' || entity.trim() === '') {
+        throw invalidInput('resetCursor needs the entity stream whose cursor to drop.', 'entity');
+    }
+    return entity;
+}
+/**
+ * A connection-log filter as the route's query. The wire cursor is `?before=` (the rows run
+ * newest first); the SDK's name for "the cursor the previous page handed me" is `after`, as on
+ * every list. An undefined value is left out of the query.
+ */
+function connectionLogQuery(filter) {
+    return {
+        before: filter.after,
+        limit: filter.limit,
+        category: filter.category,
+        outcome: filter.outcome,
+        status_code: filter.statusCode,
+        q: filter.q,
+        date_from: filter.dateFrom,
+        date_to: filter.dateTo,
+    };
+}
+/** The per-call options of a filter object (`signal`, `tenant`, `idempotencyKey`). */
+function callOf(filter) {
+    if (!filter)
+        return {};
+    const { signal, tenant, idempotencyKey } = filter;
+    return {
+        ...(signal === undefined ? {} : { signal }),
+        ...(tenant === undefined ? {} : { tenant }),
+        ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
+    };
+}
 export function createExactOnlineModule(transport) {
     const read = (document, field, options, variables = {}) => fieldOf(transport, document, field, variables, options);
+    async function connectionLogCalls(filter) {
+        const body = await transport.rest('plugins', { method: 'GET', path: `${CONNECTION_LOGS}/calls`, query: connectionLogQuery(filter ?? {}) }, { ...callOf(filter), preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+        const { items, meta } = readRestPage(body);
+        return createPage(items, meta, (cursor) => connectionLogCalls({ ...filter, after: cursor }));
+    }
+    async function connectionLogEvents(filter) {
+        const body = await transport.rest('plugins', { method: 'GET', path: `${CONNECTION_LOGS}/events`, query: connectionLogQuery(filter ?? {}) }, { ...callOf(filter), preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+        const { items, meta } = readRestPage(body);
+        return createPage(items, meta, (cursor) => connectionLogEvents({ ...filter, after: cursor }));
+    }
     return {
         config: {
             async get(options) {
@@ -372,5 +922,168 @@ export function createExactOnlineModule(transport) {
         async syncEstimate(schedule, options) {
             return read(EXACT_ONLINE_SYNC_ESTIMATE_QUERY, 'exactOnlineSyncEstimate', options, { schedule: requireObject(schedule, 'syncEstimate') });
         },
+        sync: {
+            async logs(options) {
+                const { entity, limit, ...call } = options ?? {};
+                return read(EXACT_ONLINE_SYNC_LOGS_QUERY, 'exactOnlineSyncLogs', call, syncLogVariables({ entity, limit }));
+            },
+            health(options) {
+                return read(EXACT_ONLINE_SYNC_HEALTH_QUERY, 'exactOnlineSyncHealth', options);
+            },
+            async runCatalogue(options) {
+                return ((await read(RUN_EXACT_ONLINE_CATALOGUE_SYNC_MUTATION, 'runExactOnlineCatalogueSync', options)) === true);
+            },
+            async runCustomers(options) {
+                return ((await read(RUN_EXACT_ONLINE_CUSTOMER_SYNC_MUTATION, 'runExactOnlineCustomerSync', options)) === true);
+            },
+            async runPriceLists(options) {
+                return ((await read(RUN_EXACT_ONLINE_PRICE_LIST_SYNC_MUTATION, 'runExactOnlinePriceListSync', options)) === true);
+            },
+            reimportPictures(options) {
+                return read(REIMPORT_EXACT_ONLINE_ITEM_PICTURES_MUTATION, 'reimportExactOnlineItemPictures', options);
+            },
+            cursors(options) {
+                return read(EXACT_ONLINE_SYNC_CURSORS_QUERY, 'exactOnlineSyncCursors', options);
+            },
+            async resetCursor(entity, options) {
+                return ((await read(RESET_EXACT_ONLINE_SYNC_CURSOR_MUTATION, 'resetExactOnlineSyncCursor', options, { entity: requireEntity(entity) })) === true);
+            },
+        },
+        warehouseLinks(options) {
+            return read(EXACT_ONLINE_WAREHOUSE_LINKS_QUERY, 'exactOnlineWarehouseLinks', options);
+        },
+        shipping: {
+            methods(options) {
+                return read(EXACT_ONLINE_SHIPPING_METHODS_QUERY, 'exactOnlineShippingMethods', options);
+            },
+            async runSync(options) {
+                return ((await read(RUN_EXACT_ONLINE_SHIPPING_METHOD_SYNC_MUTATION, 'runExactOnlineShippingMethodSync', options)) === true);
+            },
+            import(exactShippingMethodId, options) {
+                return read(IMPORT_EXACT_ONLINE_SHIPPING_METHOD_MUTATION, 'importExactOnlineShippingMethod', options, { exactShippingMethodId });
+            },
+            async setMapping(input, options) {
+                const { vendureShippingMethodId, exactShippingMethodId } = requireObject(input, 'shipping.setMapping');
+                // GraphQL reads a missing argument as null, and the engine trims a blank id to null: a
+                // forgotten key or an emptied field would CLEAR the mapping. Only `null` clears.
+                if (exactShippingMethodId !== null &&
+                    (typeof exactShippingMethodId !== 'string' || exactShippingMethodId.trim() === '')) {
+                    throw invalidInput('shipping.setMapping needs exactShippingMethodId: an Exact method, or null to clear the mapping.', 'exactShippingMethodId');
+                }
+                return read(SET_EXACT_ONLINE_SHIPPING_METHOD_MAPPING_MUTATION, 'setExactOnlineShippingMethodMapping', options, { vendureShippingMethodId, exactShippingMethodId });
+            },
+            async convertToMapping(input, options) {
+                const { exactShippingMethodId, vendureShippingMethodId } = requireObject(input, 'shipping.convertToMapping');
+                return read(CONVERT_EXACT_ONLINE_SHIPPING_METHOD_TO_MAPPING_MUTATION, 'convertExactOnlineShippingMethodToMapping', options, { exactShippingMethodId, vendureShippingMethodId });
+            },
+            async retireImported(exactShippingMethodId, options) {
+                return ((await read(RETIRE_EXACT_ONLINE_IMPORTED_SHIPPING_METHOD_MUTATION, 'retireExactOnlineImportedShippingMethod', options, { exactShippingMethodId })) === true);
+            },
+        },
+        terms: {
+            paymentConditions(options) {
+                return read(EXACT_ONLINE_PAYMENT_CONDITIONS_QUERY, 'exactOnlinePaymentConditions', options);
+            },
+            paymentDiagnostics(options) {
+                return read(EXACT_ONLINE_PAYMENT_TERMS_DIAGNOSTICS_QUERY, 'exactOnlinePaymentTermsDiagnostics', options);
+            },
+            paymentDryRun(options) {
+                return read(EXACT_ONLINE_PAYMENT_TERMS_DRY_RUN_QUERY, 'exactOnlinePaymentTermsDryRun', options);
+            },
+            incoterms(options) {
+                return read(EXACT_ONLINE_INCOTERMS_QUERY, 'exactOnlineIncoterms', options);
+            },
+            deliveryDiagnostics(options) {
+                return read(EXACT_ONLINE_DELIVERY_TERMS_DIAGNOSTICS_QUERY, 'exactOnlineDeliveryTermsDiagnostics', options);
+            },
+            deliveryDryRun(options) {
+                return read(EXACT_ONLINE_DELIVERY_TERMS_DRY_RUN_QUERY, 'exactOnlineDeliveryTermsDryRun', options);
+            },
+        },
+        customers: {
+            async paymentTerms(customerId, options) {
+                return ((await read(EXACT_ONLINE_CUSTOMER_PAYMENT_TERMS_QUERY, 'exactOnlineCustomerPaymentTerms', options, { customerId: requireId(customerId, 'customerId', 'customers.paymentTerms') })) ?? null);
+            },
+            async deliveryTerms(customerId, options) {
+                return ((await read(EXACT_ONLINE_CUSTOMER_DELIVERY_TERMS_QUERY, 'exactOnlineCustomerDeliveryTerms', options, { customerId: requireId(customerId, 'customerId', 'customers.deliveryTerms') })) ?? null);
+            },
+            async priceList(customerId, options) {
+                return read(EXACT_ONLINE_CUSTOMER_PRICE_LIST_QUERY, 'exactOnlineCustomerPriceList', options, { customerId: requireId(customerId, 'customerId', 'customers.priceList') });
+            },
+        },
+        orders: {
+            async state(orderId, options) {
+                const variables = { orderId: requireId(orderId, 'orderId', 'orders.state') };
+                try {
+                    return await read(EXACT_ONLINE_ORDER_STATE_QUERY, 'exactOnlineOrderState', options, variables);
+                }
+                catch (error) {
+                    if (!isUnknownFieldRejection(error))
+                        throw error;
+                    const state = await read(EXACT_ONLINE_ORDER_STATE_LEGACY_QUERY, 'exactOnlineOrderState', options, variables);
+                    return { ...state, warnings: [] };
+                }
+            },
+            async syncState(orderId, options) {
+                return ((await read(EXACT_ONLINE_ORDER_SYNC_STATE_QUERY, 'exactOnlineOrderSyncState', options, { orderId: requireId(orderId, 'orderId', 'orders.syncState') })) ?? null);
+            },
+            async push(orderId, options) {
+                const variables = { orderId: requireId(orderId, 'orderId', 'orders.push') };
+                try {
+                    return await read(PUSH_ORDER_TO_EXACT_ONLINE_MUTATION, 'pushOrderToExactOnline', options, variables);
+                }
+                catch (error) {
+                    // Only a document the engine refused before running it is sent again (see the legacy
+                    // mutation's comment): any other failure may have reached Exact and is thrown as is.
+                    if (!isUnknownFieldRejection(error))
+                        throw error;
+                    const result = await read(PUSH_ORDER_TO_EXACT_ONLINE_LEGACY_MUTATION, 'pushOrderToExactOnline', options, variables);
+                    return { ...result, warnings: null };
+                }
+            },
+            async reprice(orderId, options) {
+                return read(REPRICE_EXACT_ONLINE_ORDER_MUTATION, 'repriceExactOnlineOrder', options, { orderId: requireId(orderId, 'orderId', 'orders.reprice') });
+            },
+            repriceAll(options) {
+                return read(REPRICE_ALL_EXACT_ONLINE_IMPORTED_ORDERS_MUTATION, 'repriceAllExactOnlineImportedOrders', options);
+            },
+            async runSync(options) {
+                return ((await read(RUN_EXACT_ONLINE_ORDER_SYNC_MUTATION, 'runExactOnlineOrderSync', options)) === true);
+            },
+            async runBackfill(options) {
+                return ((await read(RUN_EXACT_ONLINE_ORDER_BACKFILL_MUTATION, 'runExactOnlineOrderBackfill', options)) === true);
+            },
+        },
+        products: {
+            async status(productId, options) {
+                const product = await read(EXACT_PRODUCT_STATUS_QUERY, 'product', options, { id: requireId(productId, 'productId', 'products.status') });
+                if (!product)
+                    return null;
+                const fields = product.customFields;
+                return {
+                    exactManaged: fields?.exactManaged ?? null,
+                    exactItemId: fields?.exactItemId ?? null,
+                    exactItemGroupId: fields?.exactItemGroupId ?? null,
+                    exactDisabledReason: fields?.exactDisabledReason ?? null,
+                };
+            },
+        },
+        connectionLogs: {
+            calls: connectionLogCalls,
+            events: connectionLogEvents,
+            async export(kind, filter, options) {
+                if (!CONNECTION_LOG_KINDS.includes(kind)) {
+                    throw invalidInput('kind must be "calls" or "events".', 'kind');
+                }
+                // A CSV body, never JSON: `blob` keeps the transport from parsing or case-converting it.
+                const answer = await transport.rest('plugins', {
+                    method: 'GET',
+                    path: `${CONNECTION_LOGS}/${kind}/export`,
+                    query: connectionLogQuery(requireObject(filter, 'connectionLogs.export')),
+                    expect: 'blob',
+                }, { timeoutMs: EXACT_ONLINE_LOG_EXPORT_TIMEOUT_MS, ...options });
+                return answer.blob.text();
+            },
+        },
     };
 }