@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/shipping/hendriks.d.ts

@@ -0,0 +1,97 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** How the order reference sent to C.J. Hendriks is prefixed. */
+export type HendriksWirePrefixMode = 'year' | 'custom';
+/** A store's C.J. Hendriks 3PL settings: one record per store. */
+export interface HendriksConfig {
+    id: string;
+    channelId: string;
+    /** Gates every Hendriks export of the store. */
+    enabled: boolean;
+    /** The plugins-service export pipeline that sends the orders; `null` is not linked. */
+    pipelineId: string | null;
+    /** `year` prefixes the current UTC year; `custom` prefixes {@link wirePrefixDigits}. */
+    wirePrefixMode: HendriksWirePrefixMode;
+    /** 1 to 4 digits without a leading zero. Only read in `custom` mode; `null` in `year` mode. */
+    wirePrefixDigits: string | null;
+    /**
+     * Refuse to export an order the source platform already sent to its own fulfillment
+     * provider. On by default: while a migrated shop is still live both systems feed the same
+     * warehouse, and neither can spot the other's reference, so the goods would ship twice.
+     */
+    blockSourceFulfilledOrders: boolean;
+    /** ISO-8601, UTC. */
+    createdAt: string;
+    /** ISO-8601, UTC. */
+    updatedAt: string;
+}
+/**
+ * A PATCH: a key left out keeps the stored value. The custom-prefix rule is judged on the
+ * RESULTING settings, so switching to `custom` needs `wirePrefixDigits` in the same call unless
+ * valid digits are already stored.
+ */
+export interface UpdateHendriksConfigInput {
+    enabled?: boolean;
+    /** `null` unlinks the pipeline. */
+    pipelineId?: string | null;
+    wirePrefixMode?: HendriksWirePrefixMode;
+    /** Cleared by the engine whenever the resulting mode is `year`. */
+    wirePrefixDigits?: string | null;
+    blockSourceFulfilledOrders?: boolean;
+}
+/**
+ * The C.J. Hendriks 3PL settings of the store the client is scoped to
+ * (`admin.shipping.hendriks.config`). There is no channel argument: a SuperAdmin head configures
+ * ANOTHER store with `admin.withTenant({ scope: { kind: 'channel', code } })`, or a per-call
+ * `tenant`.
+ */
+export interface HendriksConfigModule {
+    /**
+     * The store's settings, or `null` when it never saved any. Needs `ReadSettings`, and is
+     * answered for a store without the Hendriks plugin too (a head reads it to decide whether to
+     * show the integration).
+     *
+     * @effect read
+     * @permission ReadSettings
+     */
+    get(options?: Call): Promise<HendriksConfig | null>;
+    /**
+     * Save the settings; the first call creates the record (`enabled` off, `year` prefix,
+     * `blockSourceFulfilledOrders` on, unless given). Needs `UpdateSettings`.
+     *
+     * Refused, with nothing saved:
+     * - `HENDRIKS_CONFIG_INVALID` (`ValidationError`, 400): `custom` mode without 1 to 4 digits not
+     *   starting with 0. `details[]` names each field (`wirePrefixDigits`, `wirePrefixMode`), so a
+     *   form can put the reason on it;
+     * - `PLUGIN_ACCESS_DENIED` (`PermissionDeniedError`, 403): the store does not hold the
+     *   Hendriks plugin. An ordinary caller only: the engine never refuses a SuperAdmin on this
+     *   ground, so a SuperAdmin head that must know reads `tenant.entitlements()` on that store;
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` (`BusinessRuleError`, 422): switching the export on,
+     *   or linking a pipeline, in an organization's workspace.
+     *
+     * `pipelineId` is not checked against the store's pipelines; an export through a pipeline
+     * that does not exist fails when it runs.
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    update(input: UpdateHendriksConfigInput, options?: Call): Promise<HendriksConfig>;
+    /**
+     * Delete the store's settings record. Every Hendriks export of the store is refused until
+     * settings are saved again, and the prefix and pipeline link are gone with it. `true` when a
+     * record was deleted, `false` when the store had none. Needs `UpdateSettings`; allowed for a
+     * store that no longer holds the plugin, so it can always remove its connection.
+     *
+     * @effect destructive
+     * @permission UpdateSettings
+     */
+    delete(options?: Call): Promise<boolean>;
+}
+/** `admin.shipping.hendriks`: the C.J. Hendriks 3PL integration of the store. */
+export interface HendriksModule {
+    config: HendriksConfigModule;
+}
+export declare const HENDRIKS_CONFIG_QUERY = "\n  query HendriksConfig {\n    hendriksConfig { \n  id\n  channelId\n  enabled\n  pipelineId\n  wirePrefixMode\n  wirePrefixDigits\n  blockSourceFulfilledOrders\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const UPDATE_HENDRIKS_CONFIG_MUTATION = "\n  mutation UpdateHendriksConfig($input: UpdateHendriksConfigInput!) {\n    updateHendriksConfig(input: $input) { \n  id\n  channelId\n  enabled\n  pipelineId\n  wirePrefixMode\n  wirePrefixDigits\n  blockSourceFulfilledOrders\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const DELETE_HENDRIKS_CONFIG_MUTATION = "\n  mutation DeleteHendriksConfig {\n    deleteHendriksConfig\n  }\n";
+export declare function createHendriksModule(transport: Transport): HendriksModule;

package/dist/shipping/hendriks.js

@@ -0,0 +1,50 @@
+const CONFIG_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  enabled
+  pipelineId
+  wirePrefixMode
+  wirePrefixDigits
+  blockSourceFulfilledOrders
+  createdAt
+  updatedAt
+`;
+export const HENDRIKS_CONFIG_QUERY = /* GraphQL */ `
+  query HendriksConfig {
+    hendriksConfig { ${CONFIG_FIELDS} }
+  }
+`;
+export const UPDATE_HENDRIKS_CONFIG_MUTATION = /* GraphQL */ `
+  mutation UpdateHendriksConfig($input: UpdateHendriksConfigInput!) {
+    updateHendriksConfig(input: $input) { ${CONFIG_FIELDS} }
+  }
+`;
+export const DELETE_HENDRIKS_CONFIG_MUTATION = /* GraphQL */ `
+  mutation DeleteHendriksConfig {
+    deleteHendriksConfig
+  }
+`;
+export function createHendriksModule(transport) {
+    return {
+        config: {
+            async get(options) {
+                const data = await transport.graphql({ api: 'admin', query: HENDRIKS_CONFIG_QUERY }, options);
+                return data.hendriksConfig ?? null;
+            },
+            async update(input, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: UPDATE_HENDRIKS_CONFIG_MUTATION,
+                    // Sent as given: a key left out stays off the wire (the engine reads an absent
+                    // key as "keep"), and the engine names anything it refuses.
+                    variables: { input },
+                }, options);
+                return data.updateHendriksConfig;
+            },
+            async delete(options) {
+                const data = await transport.graphql({ api: 'admin', query: DELETE_HENDRIKS_CONFIG_MUTATION }, options);
+                return data.deleteHendriksConfig === true;
+            },
+        },
+    };
+}

package/dist/shipping/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Shipping (headless spec §9.2 `shipping`): everything about getting a store's orders to its
+ * customers. Each member lives in a file of its own and is only assembled here, so a branch
+ * that adds one (shipping methods, rate tables, a carrier) adds a file and one line.
+ */
+import type { Transport } from '@sixtyninecommerce/core';
+import { type ShippingDefinitionsModule } from './definitions.js';
+import { type FulfillmentProfilesModule } from './fulfillment-profiles.js';
+import { type HendriksModule } from './hendriks.js';
+import { type ShippingMethodsModule } from './methods.js';
+import { type MyparcelModule } from './myparcel.js';
+import { type ParcelCountSuggestionMethod } from './parcel-count-suggestion.js';
+import { type ParcelRuleModule } from './parcel-rule.js';
+import { type RateTablesModule } from './rate-tables.js';
+/** `admin.shipping` (spec §9.2 `shipping`). Always the store the client is scoped to. */
+export interface ShippingModule {
+    /** The store's shipping methods: what checkout offers and what each charges. */
+    methods: ShippingMethodsModule;
+    /** What a shipping method's calculator, checker and fulfillment handler may be. */
+    definitions: ShippingDefinitionsModule;
+    /**
+     * The weight-zone rate tables a `weight-zone-calculator` method prices with: per table its
+     * zones (postal-code ranges or countries) and per zone its weight tiers' prices.
+     */
+    rateTables: RateTablesModule;
+    /** How the store counts parcels for extra-parcel shipping charges. */
+    parcelRule: ParcelRuleModule;
+    /**
+     * How many parcels the store's rule gives a set of variant + quantity items.
+     *
+     * @effect read
+     */
+    parcelCountSuggestion: ParcelCountSuggestionMethod;
+    /** The C.J. Hendriks 3PL integration: its settings (`config`). */
+    hendriks: HendriksModule;
+    /**
+     * The MyParcel integration: its set-up (`config`: the API key, label format, on/off and webhook
+     * secret, both secrets read back masked), the carriers MyParcel offers, and the store's stock
+     * locations as parcel senders (`senders`).
+     */
+    myparcel: MyparcelModule;
+    /**
+     * The store's fulfillment profiles (warehouse + handler + shipping method + minimum), its
+     * default profile, and who is emailed per handler when a fulfilment is created.
+     */
+    fulfillmentProfiles: FulfillmentProfilesModule;
+}
+export declare function createShippingModule(transport: Transport): ShippingModule;

package/dist/shipping/index.js

@@ -0,0 +1,25 @@
+/**
+ * Shipping (headless spec §9.2 `shipping`): everything about getting a store's orders to its
+ * customers. Each member lives in a file of its own and is only assembled here, so a branch
+ * that adds one (shipping methods, rate tables, a carrier) adds a file and one line.
+ */
+import { createShippingDefinitionsModule } from './definitions.js';
+import { createFulfillmentProfilesModule, } from './fulfillment-profiles.js';
+import { createHendriksModule } from './hendriks.js';
+import { createShippingMethodsModule } from './methods.js';
+import { createMyparcelModule } from './myparcel.js';
+import { createParcelCountSuggestion, } from './parcel-count-suggestion.js';
+import { createParcelRuleModule } from './parcel-rule.js';
+import { createRateTablesModule } from './rate-tables.js';
+export function createShippingModule(transport) {
+    return {
+        methods: createShippingMethodsModule(transport),
+        definitions: createShippingDefinitionsModule(transport),
+        rateTables: createRateTablesModule(transport),
+        parcelRule: createParcelRuleModule(transport),
+        parcelCountSuggestion: createParcelCountSuggestion(transport),
+        hendriks: createHendriksModule(transport),
+        myparcel: createMyparcelModule(transport),
+        fulfillmentProfiles: createFulfillmentProfilesModule(transport),
+    };
+}

package/dist/shipping/methods.d.ts

@@ -0,0 +1,198 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import { type ConfigurableOperation, type ConfigurableOperationInput, type LanguageCode } from '../catalog/types.js';
+import type { Call, ListOptions } from '../types.js';
+/** A shipping method's name and description in one language. */
+export interface ShippingMethodTranslation {
+    id: string;
+    /** As the engine spells it: `en`, `nl`, `pt_BR`. */
+    languageCode: string;
+    name: string;
+    description: string;
+}
+/** One shipping method of the store, as its list reads it. */
+export interface ShippingMethodSummary {
+    id: string;
+    /** What checkout and a fulfillment profile name the method by. */
+    code: string;
+    /** In the language the client is set to (`tenant.language`), else the store's default. */
+    name: string;
+    /**
+     * The fulfillment handler of an order fulfilled WITHOUT a fulfillment profile (the profiles
+     * route every other one). `manual-fulfillment` unless a carrier's was picked.
+     */
+    fulfillmentHandlerCode: string;
+    /** What the method charges, with its stored arguments (every value a string). */
+    calculator: ConfigurableOperation;
+    /**
+     * The master switch: a disabled method is offered nowhere (webshop, staff, till) and a cart on
+     * it re-quotes. On unless it was switched off (a method stored before the switch existed).
+     */
+    enabled: boolean;
+    /**
+     * Offered at webshop checkout; staff orders and the till do not read it. On unless it was
+     * switched off. Only meaningful while {@link enabled}.
+     */
+    enabledInStorefront: boolean;
+    /** ISO-8601, UTC. */
+    createdAt: string;
+    /** ISO-8601, UTC. */
+    updatedAt: string;
+}
+/** One shipping method of the store, as its settings read it. */
+export interface ShippingMethod extends ShippingMethodSummary {
+    /** In the same language as {@link name}; empty when the method has none. */
+    description: string;
+    /** Which orders the method is offered for, with its stored arguments. Every method has one. */
+    checker: ConfigurableOperation;
+    /** Every language the method is named in. */
+    translations: ShippingMethodTranslation[];
+    /**
+     * The Exact Online integration created the method from one of its own shipping definitions:
+     * Exact's sync owns its code and calculator (the name is the store's). Written by that sync
+     * only; neither write here takes it.
+     */
+    exactManaged: boolean;
+    /**
+     * Added once per parcel after the first, in minor units and the calculator's own tax basis;
+     * null charges nothing, 0 is a price. Only the two flat-rate calculators
+     * (`default-shipping-calculator`, `flat-threshold-calculator`) charge it, and the store's
+     * parcel rule decides how many parcels an order is; on any other calculator a stored value is
+     * kept but charges nothing.
+     */
+    extraParcelPrice: number | null;
+}
+/**
+ * A method's name and description in one language, as a create or an update writes them. The
+ * engine keeps one row per language: writing a language the method has replaces that row's
+ * name and description, and any other language is added beside the ones it has.
+ */
+export interface ShippingMethodTranslationInput {
+    /** As the engine spells it: `en`, `nl`, `pt_BR`. */
+    languageCode: LanguageCode;
+    name: string;
+    /** Empty when left out. */
+    description?: string;
+}
+/** A new shipping method, as {@link ShippingMethodsModule.create} takes it. */
+export interface CreateShippingMethodInput {
+    code: string;
+    /**
+     * One of `shipping.definitions.get()`'s `fulfillmentHandlers`. The engine requires one; a
+     * store that routes by fulfillment profiles names `manual-fulfillment`.
+     */
+    fulfillmentHandler: string;
+    /**
+     * One of `eligibilityCheckers`, with every argument it needs (a value is always a string; lists
+     * and booleans JSON-encoded). The engine requires one; "everyone" is
+     * `default-shipping-eligibility-checker` with `orderMinimum: '0'`.
+     */
+    checker: ConfigurableOperationInput;
+    /** One of `calculators`, with its arguments. */
+    calculator: ConfigurableOperationInput;
+    /** At least the store's default language: it is the name shoppers and staff are shown. */
+    translations: ShippingMethodTranslationInput[];
+    /** On when left out. See {@link ShippingMethodSummary.enabled}. */
+    enabled?: boolean;
+    /** On when left out. */
+    enabledInStorefront?: boolean;
+    /** Minor units, or null for no charge (left out: none). See {@link ShippingMethod.extraParcelPrice}. */
+    extraParcelPrice?: number | null;
+}
+/**
+ * A change to a shipping method, as {@link ShippingMethodsModule.update} takes it. A field left
+ * out keeps what the method has. The checker can be replaced, never taken away: every method has
+ * one.
+ */
+export interface UpdateShippingMethodInput {
+    code?: string;
+    fulfillmentHandler?: string;
+    checker?: ConfigurableOperationInput;
+    calculator?: ConfigurableOperationInput;
+    translations?: ShippingMethodTranslationInput[];
+    enabled?: boolean;
+    enabledInStorefront?: boolean;
+    /** `null` clears it (no charge); left out, the stored price stays. */
+    extraParcelPrice?: number | null;
+}
+/**
+ * The store's shipping methods (`admin.shipping.methods`): what checkout offers, what a
+ * fulfillment profile and the till's delivery setting name, and what the store's shipping
+ * settings show.
+ *
+ * Every read needs `ReadSettings` or `ReadShippingMethod` (either one, so no `@permission` tag:
+ * the tag can only say "all of these"). Scoped to the channel the client is on: another store's
+ * methods are not listed, and not answered by id.
+ */
+export interface ShippingMethodsModule {
+    /**
+     * Every method of the store, enabled or not, in id order. Paged (`options.limit`, default 100,
+     * at most 1,000 or `INVALID_PAGE_SIZE`; and `options.after` from a previous page);
+     * `for await (const method of page)` walks them all.
+     *
+     * @effect read
+     */
+    list(options?: ListOptions): Promise<Page<ShippingMethodSummary>>;
+    /**
+     * One method by id, or `null` when the store the client is on has no such method: an id that
+     * does not exist, a deleted method and the id of a method only ANOTHER store holds read the
+     * same.
+     *
+     * @effect read
+     */
+    get(id: string, options?: Call): Promise<ShippingMethod | null>;
+    /**
+     * Add a shipping method to the store the client is on, and answer it as {@link get} reads it.
+     * Needs `CreateSettings` or `CreateShippingMethod` (either one). Nothing is saved when it is
+     * refused:
+     *
+     * - `INVALID_SHIPPING_METHOD_INPUT` (`ValidationError`, 400): the input's shape, checked here
+     *   before anything is sent.
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` (`BusinessRuleError`, 422): an organization's
+     *   workspace ships nothing; create the method in one of its stores.
+     * - `PLUGIN_ACCESS_DENIED` (`PermissionDeniedError`, 403): the fulfillment handler, checker or
+     *   calculator belongs to a plugin the store does not hold (a carrier, Exact Online).
+     * - The engine's own input refusal (`ValidationError`, 400): a handler, checker or calculator
+     *   code it has not registered, a missing argument, or an `extraParcelPrice` outside
+     *   0–10,000,000.
+     *
+     * @effect write
+     */
+    create(input: CreateShippingMethodInput, options?: Call): Promise<ShippingMethod>;
+    /**
+     * Change a shipping method of the store the client is on, and answer it as {@link get} reads
+     * it. A field left out keeps what the method has. Needs `UpdateSettings` or
+     * `UpdateShippingMethod` (either one).
+     *
+     * One method may be held by several stores, and a change reaches every one of them. Refused,
+     * with nothing saved, as {@link create} is (`PLUGIN_ACCESS_DENIED` only for a handler, checker
+     * or calculator the patch CHANGES: one the method already has is no new pick), and:
+     *
+     * - `ENTITY_NOT_FOUND` (`NotFoundError`, 404): the store has no such method (another store's
+     *   reads the same).
+     * - `SHARED_SHIPPING_METHOD_NOT_ALLOWED` (`PermissionDeniedError`, 403): the method is shared
+     *   with another store where the caller lacks `UpdateSettings` or `UpdateShippingMethod`.
+     *
+     * @effect write
+     */
+    update(id: string, patch: UpdateShippingMethodInput, options?: Call): Promise<ShippingMethod>;
+    /**
+     * Delete a shipping method. The method is withdrawn from checkout in EVERY store that holds
+     * it, not only the one the client is on; orders already shipped with it keep their shipping
+     * line. Needs `DeleteSettings` or `DeleteShippingMethod` (either one), and the same in every
+     * other store holding the method, else `SHARED_SHIPPING_METHOD_NOT_ALLOWED`
+     * (`PermissionDeniedError`, 403) and nothing is deleted.
+     *
+     * `ENTITY_NOT_FOUND` (`NotFoundError`, 404): the store has no such method, or it is already
+     * deleted. A refusal the engine answers as a result rather than an error is
+     * `SHIPPING_METHOD_NOT_DELETED` (`ConflictError`, 409) with the engine's reason.
+     *
+     * @effect destructive
+     */
+    delete(id: string, options?: Call): Promise<void>;
+}
+export declare const SHIPPING_METHODS_QUERY = "\n  query StoreShippingMethods($options: ShippingMethodListOptions) {\n    shippingMethods(options: $options) {\n      items { \n  id\n  createdAt\n  updatedAt\n  code\n  name\n  fulfillmentHandlerCode\n  calculator { \n  code\n  args {\n    name\n    value\n  }\n }\n  customFields {\n    enabled\n    enabledInStorefront\n  }\n }\n      totalItems\n    }\n  }\n";
+export declare const SHIPPING_METHOD_QUERY = "\n  query StoreShippingMethod($id: ID!) {\n    shippingMethod(id: $id) { \n  id\n  createdAt\n  updatedAt\n  code\n  name\n  description\n  fulfillmentHandlerCode\n  calculator { \n  code\n  args {\n    name\n    value\n  }\n }\n  checker { \n  code\n  args {\n    name\n    value\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n    description\n  }\n  customFields {\n    enabled\n    enabledInStorefront\n    exactManaged\n    extraParcelPrice\n  }\n }\n  }\n";
+export declare const CREATE_SHIPPING_METHOD_MUTATION = "\n  mutation CreateStoreShippingMethod($input: CreateShippingMethodInput!) {\n    createShippingMethod(input: $input) { \n  id\n  createdAt\n  updatedAt\n  code\n  name\n  description\n  fulfillmentHandlerCode\n  calculator { \n  code\n  args {\n    name\n    value\n  }\n }\n  checker { \n  code\n  args {\n    name\n    value\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n    description\n  }\n  customFields {\n    enabled\n    enabledInStorefront\n    exactManaged\n    extraParcelPrice\n  }\n }\n  }\n";
+export declare const UPDATE_SHIPPING_METHOD_MUTATION = "\n  mutation UpdateStoreShippingMethod($input: UpdateShippingMethodInput!) {\n    updateShippingMethod(input: $input) { \n  id\n  createdAt\n  updatedAt\n  code\n  name\n  description\n  fulfillmentHandlerCode\n  calculator { \n  code\n  args {\n    name\n    value\n  }\n }\n  checker { \n  code\n  args {\n    name\n    value\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n    description\n  }\n  customFields {\n    enabled\n    enabledInStorefront\n    exactManaged\n    extraParcelPrice\n  }\n }\n  }\n";
+export declare const DELETE_SHIPPING_METHOD_MUTATION = "\n  mutation DeleteStoreShippingMethod($id: ID!) {\n    deleteShippingMethod(id: $id) {\n      result\n      message\n    }\n  }\n";
+export declare function createShippingMethodsModule(transport: Transport): ShippingMethodsModule;

package/dist/shipping/methods.js

@@ -0,0 +1,240 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+import { assertDeleted, fieldOf, vendureListPage, } from '../catalog/types.js';
+/** A store has a handful; one page holds them. */
+const DEFAULT_PAGE_SIZE = 100;
+/**
+ * Vendure's list queries add no ORDER BY of their own, and `skip/take` over an unordered query
+ * can repeat or skip rows between two requests: id is the one unique key a sort can name.
+ */
+const BY_ID = { id: 'ASC' };
+const OPERATION_FIELDS = /* GraphQL */ `
+  code
+  args {
+    name
+    value
+  }
+`;
+const SUMMARY_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  updatedAt
+  code
+  name
+  fulfillmentHandlerCode
+  calculator { ${OPERATION_FIELDS} }
+  customFields {
+    enabled
+    enabledInStorefront
+  }
+`;
+/** One selection for the single read and both writes, so all three answer the same method. */
+const METHOD_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  updatedAt
+  code
+  name
+  description
+  fulfillmentHandlerCode
+  calculator { ${OPERATION_FIELDS} }
+  checker { ${OPERATION_FIELDS} }
+  translations {
+    id
+    languageCode
+    name
+    description
+  }
+  customFields {
+    enabled
+    enabledInStorefront
+    exactManaged
+    extraParcelPrice
+  }
+`;
+export const SHIPPING_METHODS_QUERY = /* GraphQL */ `
+  query StoreShippingMethods($options: ShippingMethodListOptions) {
+    shippingMethods(options: $options) {
+      items { ${SUMMARY_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const SHIPPING_METHOD_QUERY = /* GraphQL */ `
+  query StoreShippingMethod($id: ID!) {
+    shippingMethod(id: $id) { ${METHOD_FIELDS} }
+  }
+`;
+export const CREATE_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation CreateStoreShippingMethod($input: CreateShippingMethodInput!) {
+    createShippingMethod(input: $input) { ${METHOD_FIELDS} }
+  }
+`;
+export const UPDATE_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation UpdateStoreShippingMethod($input: UpdateShippingMethodInput!) {
+    updateShippingMethod(input: $input) { ${METHOD_FIELDS} }
+  }
+`;
+export const DELETE_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation DeleteStoreShippingMethod($id: ID!) {
+    deleteShippingMethod(id: $id) {
+      result
+      message
+    }
+  }
+`;
+const invalidInput = (message) => new ValidationError({
+    code: 'INVALID_SHIPPING_METHOD_INPUT',
+    message,
+    status: 400,
+    service: 'vendure',
+});
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** A handler-like operation as the engine takes it, checked here so a wrong shape never leaves. */
+function operationInput(value, what) {
+    if (!isObject(value) || typeof value.code !== 'string' || value.code === '') {
+        throw invalidInput(`${what} needs a code.`);
+    }
+    const args = value.arguments;
+    if (!Array.isArray(args) ||
+        !args.every((arg) => isObject(arg) && typeof arg.name === 'string' && typeof arg.value === 'string')) {
+        throw invalidInput(`${what}.arguments must be a list of { name, value } strings (a list or a boolean JSON-encoded).`);
+    }
+    return {
+        code: value.code,
+        arguments: args.map((arg) => ({ name: String(arg.name), value: String(arg.value) })),
+    };
+}
+function translationsInput(value) {
+    if (!Array.isArray(value) ||
+        !value.every((row) => isObject(row) &&
+            typeof row.languageCode === 'string' &&
+            row.languageCode !== '' &&
+            typeof row.name === 'string' &&
+            (row.description === undefined || typeof row.description === 'string'))) {
+        throw invalidInput('translations must be a list of { languageCode, name, description? } with strings.');
+    }
+    return value.map((row) => ({
+        languageCode: String(row.languageCode),
+        name: String(row.name),
+        description: typeof row.description === 'string' ? row.description : '',
+    }));
+}
+/**
+ * The fields both writes share, in the engine's shape: the three store switches under
+ * `customFields`. The range of `extraParcelPrice` is the engine's to judge.
+ */
+function sharedInput(input) {
+    const out = {};
+    if (input.code !== undefined) {
+        if (typeof input.code !== 'string' || input.code === '') {
+            throw invalidInput('code must be a non-empty string.');
+        }
+        out.code = input.code;
+    }
+    if (input.fulfillmentHandler !== undefined) {
+        if (typeof input.fulfillmentHandler !== 'string' || input.fulfillmentHandler === '') {
+            throw invalidInput('fulfillmentHandler must be a fulfillment handler code.');
+        }
+        out.fulfillmentHandler = input.fulfillmentHandler;
+    }
+    if (input.checker === null) {
+        throw invalidInput('Every shipping method has a checker: send default-shipping-eligibility-checker for "everyone".');
+    }
+    if (input.checker !== undefined)
+        out.checker = operationInput(input.checker, 'checker');
+    if (input.calculator !== undefined) {
+        out.calculator = operationInput(input.calculator, 'calculator');
+    }
+    if (input.translations !== undefined)
+        out.translations = translationsInput(input.translations);
+    const customFields = {};
+    for (const flag of ['enabled', 'enabledInStorefront']) {
+        const value = input[flag];
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'boolean')
+            throw invalidInput(`${flag} must be true or false.`);
+        customFields[flag] = value;
+    }
+    const extra = input.extraParcelPrice;
+    if (extra !== undefined) {
+        if (extra !== null && (typeof extra !== 'number' || !Number.isSafeInteger(extra))) {
+            throw invalidInput('extraParcelPrice must be a whole number of minor units, or null.');
+        }
+        customFields.extraParcelPrice = extra;
+    }
+    if (Object.keys(customFields).length > 0)
+        out.customFields = customFields;
+    return out;
+}
+const toSummary = (method) => ({
+    id: method.id,
+    code: method.code,
+    name: method.name,
+    fulfillmentHandlerCode: method.fulfillmentHandlerCode,
+    calculator: method.calculator,
+    // A switch the engine did not answer (a method stored before it existed) reads as ON: the
+    // checkout's own rule (`shipping-method-enabled.ts` in the shipping-calculator plugin) is the same fail-open one.
+    enabled: method.customFields?.enabled !== false,
+    enabledInStorefront: method.customFields?.enabledInStorefront !== false,
+    createdAt: method.createdAt,
+    updatedAt: method.updatedAt,
+});
+const toMethod = (method) => {
+    const extra = method.customFields?.extraParcelPrice;
+    return {
+        ...toSummary(method),
+        description: method.description,
+        checker: method.checker,
+        translations: method.translations,
+        exactManaged: method.customFields?.exactManaged === true,
+        extraParcelPrice: typeof extra === 'number' ? extra : null,
+    };
+};
+const requireId = (id) => {
+    if (typeof id !== 'string' || id === '')
+        throw invalidInput('id must be a shipping method id.');
+    return id;
+};
+export function createShippingMethodsModule(transport) {
+    return {
+        list(options) {
+            return vendureListPage(transport, SHIPPING_METHODS_QUERY, 'shippingMethods', (skip, take) => ({ options: { skip, take, sort: BY_ID } }), { ...options, limit: options?.limit ?? DEFAULT_PAGE_SIZE }, toSummary);
+        },
+        async get(id, options) {
+            const method = await fieldOf(transport, SHIPPING_METHOD_QUERY, 'shippingMethod', { id: requireId(id) }, options);
+            return method ? toMethod(method) : null;
+        },
+        async create(input, options) {
+            if (!isObject(input))
+                throw invalidInput('A new shipping method must be an object.');
+            if (input.code === undefined)
+                throw invalidInput('A shipping method needs a code.');
+            if (input.fulfillmentHandler === undefined) {
+                throw invalidInput('A shipping method needs a fulfillment handler.');
+            }
+            if (input.checker === undefined)
+                throw invalidInput('A shipping method needs a checker.');
+            if (input.calculator === undefined) {
+                throw invalidInput('A shipping method needs a calculator.');
+            }
+            if (input.translations === undefined) {
+                throw invalidInput('A shipping method needs its name in at least one language.');
+            }
+            return toMethod(await fieldOf(transport, CREATE_SHIPPING_METHOD_MUTATION, 'createShippingMethod', { input: sharedInput(input) }, options));
+        },
+        async update(id, patch, options) {
+            const methodId = requireId(id);
+            if (!isObject(patch))
+                throw invalidInput('The change to a shipping method must be an object.');
+            const input = sharedInput(patch);
+            // The engine's input REQUIRES a translations list; an empty one changes no name.
+            return toMethod(await fieldOf(transport, UPDATE_SHIPPING_METHOD_MUTATION, 'updateShippingMethod', { input: { id: methodId, translations: [], ...input } }, options));
+        },
+        async delete(id, options) {
+            assertDeleted('SHIPPING_METHOD_NOT_DELETED', [
+                await fieldOf(transport, DELETE_SHIPPING_METHOD_MUTATION, 'deleteShippingMethod', { id: requireId(id) }, options),
+            ]);
+        },
+    };
+}