@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/shipping/myparcel.d.ts

@@ -0,0 +1,254 @@
+import { type PlatformError, type Transport, type VendureErrorResult } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * The store-wide default label format: `A4` or `A6` paper, or `BOTH`, which has MyParcel make
+ * both for every new fulfillment.
+ */
+export type MyparcelLabelFormat = 'A4' | 'A6' | 'BOTH';
+/**
+ * A store's MyParcel set-up, as every reader gets it: both secrets masked. The API key is never
+ * readable again once saved, and the webhook secret is only ever needed by the platform itself
+ * (it registers the callback URL at MyParcel), so neither is answered in clear here.
+ */
+export interface MyparcelConfig {
+    id: string;
+    channelId: string;
+    /** A key is stored. */
+    hasApiKey: boolean;
+    /**
+     * The key's preview, for display only: mask glyphs (`•`) and its last 4 characters. It is never
+     * the key: `update` refuses it (`SECRET_ARG_MASK_INVALID`).
+     */
+    maskedApiKey: string;
+    /** The webhook secret's preview, for display only: 8 mask glyphs and its last 4 characters. */
+    maskedWebhookSecret: string;
+    defaultLabelFormat: MyparcelLabelFormat;
+    /** MyParcel is on for the store. Independent of the key: switching off keeps it. */
+    enabled: boolean;
+}
+/** What `config.update` takes: the key alone. */
+export interface UpdateMyparcelConfigInput {
+    /** The MyParcel API key, from the store's MyParcel account. Trimmed; never empty. */
+    apiKey: string;
+}
+/** A carrier MyParcel offers. The list is the same for every store (`GET /carriers`). */
+export interface MyparcelCarrier {
+    /** MyParcel's carrier id, as a shipment names it. */
+    id: number;
+    /** The carrier's slug (`postnl`, `dhlforyou`, …). */
+    name: string;
+    /** Its name for people (`PostNL`). */
+    human: string;
+    /** MyParcel's logo links; `''` where MyParcel has none. */
+    meta: {
+        logoSvg: string;
+        logoPng: string;
+    };
+}
+/** A stock location's parcel sender address. */
+export interface MyparcelSenderAddress {
+    streetLine1: string;
+    streetLine2: string | null;
+    city: string;
+    postalCode: string;
+    province: string | null;
+    /** ISO 3166-1 alpha-2, upper case. */
+    countryCode: string;
+    phoneNumber: string | null;
+    contactName: string | null;
+    company: string | null;
+}
+/** One stock location of the store as a parcel sender. */
+export interface MyparcelSenderLocation {
+    /** The stock location's id. */
+    id: string;
+    name: string;
+    /** Its sender address, or `null` when none is stored or the stored one does not parse. */
+    address: MyparcelSenderAddress | null;
+    /** The store's default sender: a shipment that names no location ships from it. */
+    isDefaultSender: boolean;
+    /** The address has every field a shipment needs (street, city, postal code, country). */
+    isResolvable: boolean;
+}
+/** What `senders.set` writes. */
+export interface SetMyparcelSenderInput {
+    stockLocationId: string;
+    /** The whole address. `null` or a blank optional field is stored as absent. */
+    address: {
+        streetLine1: string;
+        streetLine2?: string | null;
+        city: string;
+        postalCode: string;
+        province?: string | null;
+        countryCode: string;
+        phoneNumber?: string | null;
+        contactName?: string | null;
+        company?: string | null;
+    };
+    /**
+     * Make this location the store's default sender (`true`) or not. Send the location's CURRENT
+     * flag to change the address alone: only a change of the flag is judged and written.
+     */
+    isDefault: boolean;
+}
+/**
+ * The MyParcel set-up of the store the client is scoped to (`admin.shipping.myparcel.config`).
+ * There is no channel argument: a SuperAdmin head configures ANOTHER store with
+ * `admin.withTenant({ scope: { kind: 'channel', code } })`, or a per-call `tenant`.
+ *
+ * Every method needs `UpdateSettings`. An app installation is refused all of them
+ * (`APP_CREDENTIAL_NOT_ALLOWED`), the read included: the engine still answers the webhook secret
+ * in clear on an older field of the same object. A store without the MyParcel plugin is refused
+ * `PLUGIN_ACCESS_DENIED` (`PermissionDeniedError`, 403) on every write, `remove` included, for an
+ * ordinary caller; the engine never refuses a SuperAdmin on that ground.
+ */
+export interface MyparcelConfigModule {
+    /**
+     * The store's set-up, or `null` when no key was ever saved (or it was removed). A stored key the
+     * engine can no longer decrypt (its encryption key was rotated) fails this read with the
+     * engine's internal error (code `INTERNAL_SERVER_ERROR`: a non-retryable 500, raised as
+     * `UpstreamError`), not a coded refusal: the read is not a union. Saving the key again with `update` repairs it; the writes answer the
+     * same condition as `MYPARCEL_DECRYPTION_FAILED_ERROR` (`BusinessRuleError`, 422).
+     *
+     * @effect read
+     * @permission UpdateSettings
+     */
+    get(options?: Call): Promise<MyparcelConfig | null>;
+    /**
+     * Save the store's API key; the first save also switches MyParcel on, with `A6` labels and a new
+     * webhook secret. A later save replaces the key alone (the on/off switch, the label format and
+     * the webhook secret stay). The key is trimmed and stored as given: the engine does not test it
+     * against MyParcel, so a wrong key fails at the first shipment or label.
+     *
+     * An empty key is refused here (`TypeError`), never sent: an empty key REMOVES the whole set-up
+     * on the wire, and that is `remove()`'s job. The message never quotes the argument.
+     *
+     * Refused, with nothing stored:
+     * - `SECRET_ARG_MASK_INVALID` (`ValidationError`, 400, `details[0].field: 'apiKey'`): a key
+     *   carrying the mask glyph (`•`), {@link MyparcelConfig.maskedApiKey} sent back included. The
+     *   preview is never the key; leave the key alone to keep it;
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` (`BusinessRuleError`, 422): an organization's workspace
+     *   ships nothing.
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    update(input: UpdateMyparcelConfigInput, options?: Call): Promise<MyparcelConfig>;
+    /**
+     * Remove the store's MyParcel set-up: the API key, the label format, the on/off switch AND the
+     * webhook secret. MyParcel's status and label callbacks for the store are refused from then on,
+     * and every MyParcel shipment or label of the store is refused (`MYPARCEL_NOT_CONFIGURED_ERROR`)
+     * until a key is saved again, which mints a new webhook secret. Resolves when the store has no
+     * set-up any more, also when it had none. Allowed in an organization's workspace.
+     *
+     * @effect destructive
+     * @permission UpdateSettings
+     */
+    remove(options?: Call): Promise<void>;
+    /**
+     * Set the store-wide default label format. A fulfillment's own format, when it has one, wins.
+     *
+     * Refused: `MYPARCEL_NOT_CONFIGURED_ERROR` (`BusinessRuleError`, 422) before a key is saved;
+     * `MYPARCEL_INVALID_LABEL_FORMAT_ERROR` (422) for any other value.
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    setLabelFormat(format: MyparcelLabelFormat, options?: Call): Promise<MyparcelConfig>;
+    /**
+     * Switch MyParcel on or off for the store without touching the key or the webhook secret. Off,
+     * every new MyParcel shipment and label of the store is refused; what MyParcel already holds is
+     * left as it is.
+     *
+     * Refused: `MYPARCEL_NOT_CONFIGURED_ERROR` (`BusinessRuleError`, 422) before a key is saved;
+     * switching ON in an organization's workspace, `ORGANIZATION_WORKSPACE_NOT_A_STORE` (422).
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    setEnabled(enabled: boolean, options?: Call): Promise<MyparcelConfig>;
+    /**
+     * Replace the store's webhook secret, answering the set-up with the NEW secret's preview (the
+     * secret itself is never answered). The old secret stops authenticating at once, and MyParcel
+     * keeps calling the old callback URL, refused, until the engine's worker registers the webhooks
+     * again, which it does when it starts. Status and label updates sent meanwhile are lost.
+     *
+     * The secret is answered in clear by the engine's older `webhookSecret` field and stored in
+     * clear; hashing it at rest is an open follow-up, after which only a preview can be read.
+     *
+     * Refused: `MYPARCEL_NOT_CONFIGURED_ERROR` (`BusinessRuleError`, 422) before a key is saved.
+     *
+     * @effect destructive
+     * @permission UpdateSettings
+     */
+    regenerateWebhookSecret(options?: Call): Promise<MyparcelConfig>;
+}
+/**
+ * The stock locations of the store as MyParcel parcel senders (`admin.shipping.myparcel.senders`).
+ * A location's sender address and default flag are columns of its ONE row, so a location several
+ * stores hold has one sender for all of them.
+ */
+export interface MyparcelSendersModule {
+    /**
+     * Every stock location of the store with its sender address, default flag and whether a
+     * shipment can ship from it. Needs `ReadStockLocation`; answered whether or not MyParcel is set
+     * up.
+     *
+     * @effect read
+     * @permission ReadStockLocation
+     */
+    list(options?: Call): Promise<MyparcelSenderLocation[]>;
+    /**
+     * Set a stock location's sender address, and whether it is the store's default sender. Making it
+     * the default clears the flag on the store's other locations in the same transaction, so the
+     * store keeps exactly one. This is the one door that writes either column: core's stock-location
+     * create and update refuse a change to them (`STOCK_LOCATION_SENDER_READ_ONLY`).
+     *
+     * Refused, with nothing written:
+     * - `MYPARCEL_INVALID_SENDER_ERROR` (`BusinessRuleError`, 422): a mandatory field missing or a
+     *   country code that is not 2 letters; `details[]` names each field (`streetLine1`, `city`,
+     *   `postalCode`, `countryCode`);
+     * - `MYPARCEL_STOCK_LOCATION_NOT_FOUND_ERROR` (`NotFoundError`, 404): no such location in the
+     *   store (another store's, a missing and a malformed id alike);
+     * - `SHARED_STOCK_LOCATION_NOT_ALLOWED` (403): the location, or a default it would clear, is
+     *   also another store's, and the caller may not update stock locations there;
+     * - `LOCATION_NOT_ALLOWED` (403): a credential restricted to some locations names, or would
+     *   clear the default of, one it does not hold;
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` / `DEFAULT_SENDER_NOT_A_STORE` (422): changing the
+     *   default flag in an organization's workspace or on the platform root. Sending the current
+     *   flag there saves the address alone.
+     *
+     * @effect write
+     * @permission UpdateStockLocation
+     */
+    set(input: SetMyparcelSenderInput, options?: Call): Promise<MyparcelSenderLocation>;
+}
+/** `admin.shipping.myparcel`: the MyParcel integration of the store. */
+export interface MyparcelModule {
+    config: MyparcelConfigModule;
+    /**
+     * The carriers MyParcel offers, the same list for every store (cached by the engine for an
+     * hour). What a carrier can do for one address is not in it. Needs `ReadSettings`; a store
+     * without the MyParcel plugin is refused `PLUGIN_ACCESS_DENIED` (403).
+     *
+     * @effect read
+     * @permission ReadSettings
+     */
+    carriers(options?: Call): Promise<MyparcelCarrier[]>;
+    senders: MyparcelSendersModule;
+}
+export declare const MYPARCEL_CONFIG_QUERY = "\n  query MyparcelConfig {\n    myparcelConfig { \n  id\n  channelId\n  hasApiKey\n  maskedApiKey\n  maskedWebhookSecret\n  defaultLabelFormat\n  enabled\n }\n  }\n";
+export declare const UPDATE_MYPARCEL_CONFIG_MUTATION = "\n  mutation UpdateMyparcelConfig($input: MyparcelConfigInput!) {\n    updateMyparcelConfig(input: $input) {\n      \n  __typename\n  ... on MyparcelConfig { \n  id\n  channelId\n  hasApiKey\n  maskedApiKey\n  maskedWebhookSecret\n  defaultLabelFormat\n  enabled\n }\n  ... on ErrorResult { errorCode message }\n\n      ... on MyparcelValidationError { errors }\n    }\n  }\n";
+export declare const UPDATE_MYPARCEL_LABEL_FORMAT_MUTATION = "\n  mutation UpdateMyparcelLabelFormat($input: MyparcelLabelFormatInput!) {\n    updateMyparcelLabelFormat(input: $input) { \n  __typename\n  ... on MyparcelConfig { \n  id\n  channelId\n  hasApiKey\n  maskedApiKey\n  maskedWebhookSecret\n  defaultLabelFormat\n  enabled\n }\n  ... on ErrorResult { errorCode message }\n }\n  }\n";
+export declare const SET_MYPARCEL_ENABLED_MUTATION = "\n  mutation SetMyparcelEnabled($enabled: Boolean!) {\n    setMyparcelEnabled(enabled: $enabled) {\n      \n  __typename\n  ... on MyparcelConfig { \n  id\n  channelId\n  hasApiKey\n  maskedApiKey\n  maskedWebhookSecret\n  defaultLabelFormat\n  enabled\n }\n  ... on ErrorResult { errorCode message }\n\n      ... on MyparcelValidationError { errors }\n    }\n  }\n";
+export declare const REGENERATE_MYPARCEL_WEBHOOK_SECRET_MUTATION = "\n  mutation RegenerateMyparcelWebhookSecret {\n    regenerateMyparcelWebhookSecret { \n  __typename\n  ... on MyparcelConfig { \n  id\n  channelId\n  hasApiKey\n  maskedApiKey\n  maskedWebhookSecret\n  defaultLabelFormat\n  enabled\n }\n  ... on ErrorResult { errorCode message }\n }\n  }\n";
+export declare const MYPARCEL_CARRIERS_QUERY = "\n  query MyparcelCarriers {\n    myparcelCarriers {\n      id\n      name\n      human\n      meta { logoSvg logoPng }\n    }\n  }\n";
+export declare const MYPARCEL_SENDERS_QUERY = "\n  query MyparcelSenderStockLocations {\n    myparcelSenderStockLocations { \n  id\n  name\n  address {\n    streetLine1\n    streetLine2\n    city\n    postalCode\n    province\n    countryCode\n    phoneNumber\n    contactName\n    company\n  }\n  isDefaultSender\n  isResolvable\n }\n  }\n";
+export declare const SET_MYPARCEL_SENDER_MUTATION = "\n  mutation SetStockLocationSender($input: MyparcelSetStockLocationSenderInput!) {\n    setStockLocationSender(input: $input) {\n      __typename\n      ... on MyparcelSenderStockLocationSummary { \n  id\n  name\n  address {\n    streetLine1\n    streetLine2\n    city\n    postalCode\n    province\n    countryCode\n    phoneNumber\n    contactName\n    company\n  }\n  isDefaultSender\n  isResolvable\n }\n      ... on ErrorResult { errorCode message }\n      ... on MyparcelInvalidSenderError { fields }\n    }\n  }\n";
+/**
+ * A refusal member as its error class, by core's `errorFromErrorResult`. The field names a member
+ * carries (`MyparcelInvalidSenderError.fields`, `MyparcelValidationError.errors`) ride
+ * `details[]`, one per field, so a form can mark each without matching the sentence.
+ */
+export declare function myparcelRefusal(result: VendureErrorResult): PlatformError;
+export declare function createMyparcelModule(transport: Transport): MyparcelModule;

package/dist/shipping/myparcel.js

@@ -0,0 +1,178 @@
+import { errorForStatus, errorFromErrorResult, isErrorResult, } from '@sixtyninecommerce/core';
+const CONFIG_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  hasApiKey
+  maskedApiKey
+  maskedWebhookSecret
+  defaultLabelFormat
+  enabled
+`;
+/** The union answer of every config write: the set-up, or a refusal. */
+const CONFIG_RESULT = /* GraphQL */ `
+  __typename
+  ... on MyparcelConfig { ${CONFIG_FIELDS} }
+  ... on ErrorResult { errorCode message }
+`;
+export const MYPARCEL_CONFIG_QUERY = /* GraphQL */ `
+  query MyparcelConfig {
+    myparcelConfig { ${CONFIG_FIELDS} }
+  }
+`;
+export const UPDATE_MYPARCEL_CONFIG_MUTATION = /* GraphQL */ `
+  mutation UpdateMyparcelConfig($input: MyparcelConfigInput!) {
+    updateMyparcelConfig(input: $input) {
+      ${CONFIG_RESULT}
+      ... on MyparcelValidationError { errors }
+    }
+  }
+`;
+export const UPDATE_MYPARCEL_LABEL_FORMAT_MUTATION = /* GraphQL */ `
+  mutation UpdateMyparcelLabelFormat($input: MyparcelLabelFormatInput!) {
+    updateMyparcelLabelFormat(input: $input) { ${CONFIG_RESULT} }
+  }
+`;
+export const SET_MYPARCEL_ENABLED_MUTATION = /* GraphQL */ `
+  mutation SetMyparcelEnabled($enabled: Boolean!) {
+    setMyparcelEnabled(enabled: $enabled) {
+      ${CONFIG_RESULT}
+      ... on MyparcelValidationError { errors }
+    }
+  }
+`;
+export const REGENERATE_MYPARCEL_WEBHOOK_SECRET_MUTATION = /* GraphQL */ `
+  mutation RegenerateMyparcelWebhookSecret {
+    regenerateMyparcelWebhookSecret { ${CONFIG_RESULT} }
+  }
+`;
+export const MYPARCEL_CARRIERS_QUERY = /* GraphQL */ `
+  query MyparcelCarriers {
+    myparcelCarriers {
+      id
+      name
+      human
+      meta { logoSvg logoPng }
+    }
+  }
+`;
+const SENDER_FIELDS = /* GraphQL */ `
+  id
+  name
+  address {
+    streetLine1
+    streetLine2
+    city
+    postalCode
+    province
+    countryCode
+    phoneNumber
+    contactName
+    company
+  }
+  isDefaultSender
+  isResolvable
+`;
+export const MYPARCEL_SENDERS_QUERY = /* GraphQL */ `
+  query MyparcelSenderStockLocations {
+    myparcelSenderStockLocations { ${SENDER_FIELDS} }
+  }
+`;
+export const SET_MYPARCEL_SENDER_MUTATION = /* GraphQL */ `
+  mutation SetStockLocationSender($input: MyparcelSetStockLocationSenderInput!) {
+    setStockLocationSender(input: $input) {
+      __typename
+      ... on MyparcelSenderStockLocationSummary { ${SENDER_FIELDS} }
+      ... on ErrorResult { errorCode message }
+      ... on MyparcelInvalidSenderError { fields }
+    }
+  }
+`;
+/** `updateMyparcelConfig` with an empty key answers this member: the set-up is gone. */
+const NOT_CONFIGURED = 'MYPARCEL_NOT_CONFIGURED_ERROR';
+/**
+ * A refusal member as its error class, by core's `errorFromErrorResult`. The field names a member
+ * carries (`MyparcelInvalidSenderError.fields`, `MyparcelValidationError.errors`) ride
+ * `details[]`, one per field, so a form can mark each without matching the sentence.
+ */
+export function myparcelRefusal(result) {
+    const base = errorFromErrorResult(result);
+    const named = Array.isArray(result.fields)
+        ? result.fields
+        : Array.isArray(result.errors)
+            ? result.errors
+            : [];
+    const details = named
+        .filter((field) => typeof field === 'string' && field.trim() !== '')
+        .map((field) => ({ field, code: base.code, message: base.message }));
+    if (details.length === 0)
+        return base;
+    return errorForStatus(base.status, {
+        code: base.code,
+        message: base.message,
+        service: 'vendure',
+        details,
+    });
+}
+function settled(answer) {
+    if (isErrorResult(answer))
+        throw myparcelRefusal(answer);
+    const { __typename: _typename, ...rest } = answer;
+    return rest;
+}
+export function createMyparcelModule(transport) {
+    const gql = (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
+    return {
+        config: {
+            async get(options) {
+                const data = await gql(MYPARCEL_CONFIG_QUERY, {}, options);
+                return data.myparcelConfig ?? null;
+            },
+            async update(input, options) {
+                const apiKey = typeof input?.apiKey === 'string' ? input.apiKey.trim() : '';
+                if (apiKey === '') {
+                    // Never quotes the argument: a key padded with whitespace must not reach a log.
+                    throw new TypeError('config.update needs a MyParcel API key; remove the stored one with config.remove().');
+                }
+                const data = await gql(UPDATE_MYPARCEL_CONFIG_MUTATION, { input: { apiKey } }, options);
+                return settled(data.updateMyparcelConfig);
+            },
+            async remove(options) {
+                // The wire's removal is an empty key, answered by the not-configured member.
+                const data = await gql(UPDATE_MYPARCEL_CONFIG_MUTATION, { input: { apiKey: '' } }, options);
+                const answer = data.updateMyparcelConfig;
+                if (isErrorResult(answer) && answer.errorCode === NOT_CONFIGURED)
+                    return;
+                if (isErrorResult(answer))
+                    throw myparcelRefusal(answer);
+                // An engine that answered a set-up kept it: never report that as removed.
+                throw new Error('MyParcel answered the set-up instead of removing it; nothing was removed.');
+            },
+            async setLabelFormat(format, options) {
+                const data = await gql(UPDATE_MYPARCEL_LABEL_FORMAT_MUTATION, { input: { format } }, options);
+                return settled(data.updateMyparcelLabelFormat);
+            },
+            async setEnabled(enabled, options) {
+                const data = await gql(SET_MYPARCEL_ENABLED_MUTATION, { enabled }, options);
+                return settled(data.setMyparcelEnabled);
+            },
+            async regenerateWebhookSecret(options) {
+                const data = await gql(REGENERATE_MYPARCEL_WEBHOOK_SECRET_MUTATION, {}, options);
+                return settled(data.regenerateMyparcelWebhookSecret);
+            },
+        },
+        async carriers(options) {
+            const data = await gql(MYPARCEL_CARRIERS_QUERY, {}, options);
+            return data.myparcelCarriers;
+        },
+        senders: {
+            async list(options) {
+                const data = await gql(MYPARCEL_SENDERS_QUERY, {}, options);
+                return data.myparcelSenderStockLocations;
+            },
+            async set(input, options) {
+                const data = await gql(SET_MYPARCEL_SENDER_MUTATION, { input }, options);
+                return settled(data.setStockLocationSender);
+            },
+        },
+    };
+}

package/dist/shipping/parcel-count-suggestion.d.ts

@@ -46,6 +46,8 @@ export interface ParcelCountSuggestion {
  * or `ReadFulfillment`. A malformed input is refused before any request with
  * `PARCEL_COUNT_INPUT_INVALID` ({@link ValidationError}); an unknown variant,
  * or another store's, is `PARCEL_COUNT_VARIANT_NOT_FOUND` (`NotFoundError`).
+ *
+ * @effect read
  */
 export type ParcelCountSuggestionMethod = (input: ParcelCountSuggestionInput, options?: Call) => Promise<ParcelCountSuggestion>;
 export declare const PARCEL_COUNT_SUGGESTION_QUERY = "\n  query ParcelCountSuggestion($input: ParcelCountSuggestionInput!) {\n    parcelCountSuggestion(input: $input) {\n      count\n      raw\n      resolvable\n      exact\n      capped\n      capacity\n      maxWeightGrams\n      unratedLines\n      unweighedLines\n      reason\n      warnings\n      destinationRequiresCustoms\n    }\n  }\n";

package/dist/shipping/parcel-rule.d.ts

@@ -36,13 +36,14 @@ export interface SetParcelRuleInput {
  * change reaches another process after that cache refreshes.
  */
 export interface ParcelRuleModule {
+    /** @effect read */
     get(options?: Call): Promise<ParcelRule>;
+    /**
+     * @effect write
+     * @permission UpdateChannel
+     */
     set(input: SetParcelRuleInput, options?: Call): Promise<ParcelRule>;
 }
-/** `admin.shipping` (spec §9.2 `shipping`). */
-export interface ShippingModule {
-    parcelRule: ParcelRuleModule;
-}
 export declare const PARCEL_RULE_QUERY = "\n  query ParcelRule {\n    activeChannel { \n  id\n  customFields {\n    defaultParcelCapacity\n    maxParcelWeightGrams\n  }\n }\n  }\n";
 export declare const SET_PARCEL_RULE_MUTATION = "\n  mutation SetParcelRule($input: UpdateChannelInput!) {\n    updateChannel(input: $input) {\n      ... on Channel { \n  id\n  customFields {\n    defaultParcelCapacity\n    maxParcelWeightGrams\n  }\n }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
-export declare function createShippingModule(transport: Transport): ShippingModule;
+export declare function createParcelRuleModule(transport: Transport): ParcelRuleModule;

package/dist/shipping/parcel-rule.js

@@ -58,34 +58,32 @@ function customFieldsOf(input) {
     }
     return fields;
 }
-export function createShippingModule(transport) {
+export function createParcelRuleModule(transport) {
     const get = async (options) => {
         const data = await transport.graphql({ api: 'admin', query: PARCEL_RULE_QUERY }, options);
         return toRule(data.activeChannel);
     };
     return {
-        parcelRule: {
-            get,
-            async set(input, options) {
-                assertBound('defaultParcelCapacity', input?.defaultParcelCapacity, PARCEL_CAPACITY_MAX, 'items');
-                assertBound('maxParcelWeightGrams', input?.maxParcelWeightGrams, PARCEL_WEIGHT_GRAMS_MAX, 'grams');
-                const customFields = customFieldsOf(input ?? {});
-                if (Object.keys(customFields).length === 0) {
-                    throw invalid('input', 'Pass defaultParcelCapacity and/or maxParcelWeightGrams; an empty input changes nothing.');
-                }
-                // `updateChannel` needs the id, and the active channel is the one the
-                // client is scoped to — read it with the SAME call options, so a
-                // per-call tenant writes its own channel rather than the client's.
-                const { channelId } = await get(options);
-                const data = await transport.graphql({
-                    api: 'admin',
-                    query: SET_PARCEL_RULE_MUTATION,
-                    variables: { input: { id: channelId, customFields } },
-                }, options);
-                if (isErrorResult(data.updateChannel))
-                    throw errorFromErrorResult(data.updateChannel);
-                return toRule(data.updateChannel);
-            },
+        get,
+        async set(input, options) {
+            assertBound('defaultParcelCapacity', input?.defaultParcelCapacity, PARCEL_CAPACITY_MAX, 'items');
+            assertBound('maxParcelWeightGrams', input?.maxParcelWeightGrams, PARCEL_WEIGHT_GRAMS_MAX, 'grams');
+            const customFields = customFieldsOf(input ?? {});
+            if (Object.keys(customFields).length === 0) {
+                throw invalid('input', 'Pass defaultParcelCapacity and/or maxParcelWeightGrams; an empty input changes nothing.');
+            }
+            // `updateChannel` needs the id, and the active channel is the one the
+            // client is scoped to — read it with the SAME call options, so a
+            // per-call tenant writes its own channel rather than the client's.
+            const { channelId } = await get(options);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_PARCEL_RULE_MUTATION,
+                variables: { input: { id: channelId, customFields } },
+            }, options);
+            if (isErrorResult(data.updateChannel))
+                throw errorFromErrorResult(data.updateChannel);
+            return toRule(data.updateChannel);
         },
     };
 }