@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/pickups/index.js

@@ -0,0 +1,105 @@
+import { redactionWatcher } from '../customer-data-redaction.js';
+/**
+ * Store pickup (click & collect, POS C1/33): webshop orders a shopper collects at one of the
+ * store's shops. Placing such an order writes its pickup (`preparing`); "ready" starts the hold
+ * and emails the customer once; the shop's till hands it over (`collected`); a ready pickup not
+ * collected within the location's hold days goes back to stock (`expired`), and the pickup of a
+ * cancelled order is `cancelled`. A location's settings are `admin.locations.pickup/setPickup`.
+ */
+/** The statuses a pickup has today. More may come: read any other value as itself. */
+export const STORE_PICKUP_STATUSES = [
+    'preparing',
+    'ready',
+    'collected',
+    'expired',
+    'cancelled',
+];
+/**
+ * Why the release at expiry moved nothing (D23): `invoice_locked`, the order is invoiced and
+ * locked; `order_state`, the order is past the states a reservation is released from. More may
+ * come.
+ */
+export const STORE_PICKUP_RELEASE_BLOCKED = ['invoice_locked', 'order_state'];
+const STORE_PICKUP_FIELDS = /* GraphQL */ `
+  id
+  orderId
+  orderCode
+  stockLocationId
+  stockLocationName
+  status
+  customerName
+  totalQuantity
+  stockShort
+  placedAt
+  readyAt
+  holdUntil
+  collectedAt
+  expiredAt
+  releaseBlocked
+  createdAt
+`;
+export const STORE_PICKUPS_QUERY = /* GraphQL */ `
+  query StorePickups($input: StorePickupListInput) {
+    storePickups(input: $input) {
+      items { ${STORE_PICKUP_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const STORE_PICKUP_FOR_ORDER_QUERY = /* GraphQL */ `
+  query StorePickupForOrder($orderId: ID!) {
+    storePickupForOrder(orderId: $orderId) { ${STORE_PICKUP_FIELDS} }
+  }
+`;
+export const MARK_STORE_PICKUP_READY_MUTATION = /* GraphQL */ `
+  mutation MarkStorePickupReady($id: ID!) {
+    markStorePickupReady(id: $id) { ${STORE_PICKUP_FIELDS} }
+  }
+`;
+export function createPickupsModule(transport) {
+    return {
+        async list(filter, options) {
+            const redaction = redactionWatcher();
+            // Only what the caller set: an absent key leaves the engine's default (50, every status).
+            const input = {};
+            if (filter?.stockLocationId !== undefined)
+                input.stockLocationId = filter.stockLocationId;
+            if (filter?.statuses !== undefined)
+                input.statuses = [...filter.statuses];
+            if (filter?.take !== undefined)
+                input.take = filter.take;
+            if (filter?.skip !== undefined)
+                input.skip = filter.skip;
+            const data = await transport.graphql({
+                api: 'admin',
+                query: STORE_PICKUPS_QUERY,
+                variables: { input },
+                onExtensions: redaction.onExtensions,
+            }, options);
+            return {
+                items: data.storePickups.items.map((item) => redaction.mark(item)),
+                totalItems: data.storePickups.totalItems,
+            };
+        },
+        async forOrder(orderId, options) {
+            const redaction = redactionWatcher();
+            const data = await transport.graphql({
+                api: 'admin',
+                query: STORE_PICKUP_FOR_ORDER_QUERY,
+                variables: { orderId },
+                onExtensions: redaction.onExtensions,
+            }, options);
+            return redaction.mark(data.storePickupForOrder);
+        },
+        async markReady(id, options) {
+            const redaction = redactionWatcher();
+            const data = await transport.graphql({
+                api: 'admin',
+                query: MARK_STORE_PICKUP_READY_MUTATION,
+                variables: { id },
+                onExtensions: redaction.onExtensions,
+            }, options);
+            return redaction.mark(data.markStorePickupReady);
+        },
+    };
+}

package/dist/platform/channels.d.ts

@@ -0,0 +1,132 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { AdminClientConfig } from '../client.js';
+import { type JobHandle } from '../jobs/index.js';
+import type { Call } from '../types.js';
+/**
+ * Why a code is held:
+ * - `rename-source`: the code a rename is moving OFF, held until its files are moved forward.
+ * - `rename-target`: the code a rename is moving ONTO.
+ * - `rename-alias`: a renamed store's old code, still answering for its storefronts until
+ *   `expiresAt`.
+ */
+export type ChannelCodeHoldReason = 'rename-source' | 'rename-target' | 'rename-alias';
+/** What a hold's rename job is doing: `running` blocks a release; the rest are releasable. */
+export type ChannelCodeHoldActivity = 'running' | 'stalled' | 'finished' | 'no-job';
+/** Why a release ended without freeing the code. The hold stays; releasing again retries. */
+export interface ChannelCodeReleaseFailure {
+    /**
+     * `CLEANUP_FAILED` (the cleanup failed, reported errors, or stopped short), `CLEANUP_JOB_LOST`
+     * (the plugins service no longer knows the cleanup), `CLEANUP_LEFT_OBJECTS` (objects remained
+     * after a cleanup that reported success), `CLEANUP_TIMED_OUT` (not decided within 24 hours), or
+     * `CHANNEL_CODE_TAKEN` (another store took the code meanwhile).
+     */
+    code: string;
+    message: string;
+}
+/** A code a rename still holds against reuse, with what is happening to it. */
+export interface ChannelCodeReservation {
+    code: string;
+    channelId: string | null;
+    /** The code that store carries NOW; null when the store is gone. */
+    channelCode: string | null;
+    reason: ChannelCodeHoldReason;
+    jobId: string | null;
+    jobState: string | null;
+    /** ISO-8601 UTC. */
+    jobUpdatedAt: string | null;
+    /** The rename stopped moving for longer than the recovery window. */
+    jobStale: boolean;
+    createdAt: string;
+    /** `rename-alias` only: when the old code stops answering and frees. */
+    expiresAt: string | null;
+    activity: ChannelCodeHoldActivity;
+    /** Whether {@link PlatformChannelsModule.releaseCode} may be asked now. */
+    releasable: boolean;
+    /** When a release started the cleanup it waits on (or the one that failed). */
+    releaseRequestedAt: string | null;
+    releaseCleanupJobId: string | null;
+    releaseCleanupMode: 'drain-source' | 'delete-source' | null;
+    /** Set when the last release ended without freeing the code; null while one is pending. */
+    releaseFailure: ChannelCodeReleaseFailure | null;
+}
+/** How a release ended when it ended well. */
+export type ChannelCodeReleaseOutcome = 'released' | 'aliased';
+export interface ChannelCodeRelease {
+    code: string;
+    /**
+     * - `released`: the code is free now.
+     * - `aliased`: the rename behind the hold had committed and its old code still answers for the
+     *   renamed store, so the hold became that old-code alias. Release it again to end it early.
+     * - `pending`: files remained, so the engine started a cleanup (or one already was running).
+     *   The engine finishes the release itself once the cleanup ends; nobody has to stay and call
+     *   again. Follow it with `handle.wait()`, or read `codeReservations()` later.
+     */
+    outcome: ChannelCodeReleaseOutcome | 'pending';
+    /** The cleanup a `pending` release waits on; null otherwise. */
+    cleanup: {
+        jobId: string;
+        mode: 'drain-source' | 'delete-source' | null;
+        /** Files under the prefix when the cleanup started; null for a repeat of a pending release. */
+        objectsRemaining: number | null;
+    } | null;
+    /**
+     * `runId` is the cleanup's job id when there is one, else the code. `wait()` resolves at once
+     * for a release that already ended; for a `pending` one it polls {@link
+     * PlatformChannelsModule.codeReservations} until the code is no longer held (`released`), is
+     * held as an old-code alias (`aliased`), or shows a `releaseFailure`, which it throws as
+     * `CHANNEL_CODE_RELEASE_FAILED` (a {@link BusinessRuleError}, 422) with the failure's code in
+     * `details[0].code`. Defaults: a read every 5 s, giving up after 15 minutes with
+     * `CHANNEL_CODE_RELEASE_TIMEOUT` (retryable: the release goes on regardless).
+     *
+     * When a `pending` release ends as the alias while nobody is calling (the engine's worker
+     * finished it), the engine remembers that ending until a release has answered it: the next
+     * `releaseCode` answers `aliased` again and ends nothing. This keeps an older dashboard's
+     * automatic second call from cutting the alias window short. A release that answered `aliased`
+     * itself leaves nothing to answer. Either way, to end the alias early, call `releaseCode` until
+     * it answers `released`.
+     */
+    handle: JobHandle<ChannelCodeReleaseOutcome>;
+}
+/**
+ * `admin.platform.channels` — the codes renames hold against reuse, and their release. A human
+ * SuperAdmin session only: an API token or an app credential is refused before anything is sent
+ * (`PLATFORM_REQUIRES_SESSION`), and the engine answers anyone else `FORBIDDEN`.
+ */
+export interface PlatformChannelsModule {
+    /** Every live hold on the platform, oldest first. */
+    codeReservations(options?: Call): Promise<ChannelCodeReservation[]>;
+    /**
+     * Free a held code, or start the cleanup that makes that safe. Refusals:
+     * - `CHANNEL_CODE_HOLD_NOT_FOUND` (404): nothing holds that code.
+     * - `CHANNEL_CODE_RELEASE_CONFLICT` (409): something live is in the way; `details[0].code` is
+     *   `rename_queued`, `rename_running`, `rename_stalled_postponed`, `move_running` or
+     *   `cdn_route`.
+     * - `CHANNEL_CODE_TAKEN` (409): another store carries the code.
+     * - `CHANNEL_CODE_RELEASE_UNVERIFIED` (422): the object store, the store's object moves, the
+     *   CDN route, the database or the content service could not be read. Nothing changed; it is
+     *   safe to try again (`details[0].code` names what).
+     *
+     * - `CHANNEL_CODE_RELEASE_FAILED` (422): a repeat of a pending release found it ended without
+     *   freeing the code; `details[0].code` is the failure's code (`CLEANUP_…`).
+     *
+     * A repeat while a release is pending starts nothing: it finishes the release if its cleanup
+     * has ended, and answers `released`, `aliased`, the same `pending` while the cleanup runs, or
+     * the failure above. A cleanup that has ended but whose release cannot finish right now is
+     * refused with the reason (`CHANNEL_CODE_RELEASE_CONFLICT` or `…_UNVERIFIED`). A repeat after
+     * a failure has been answered is a fresh attempt.
+     */
+    releaseCode(code: string, options?: Call): Promise<ChannelCodeRelease>;
+}
+export declare const CHANNEL_CODE_RESERVATIONS_QUERY = "\n  query PlatformChannelCodeReservations {\n    channelCodeReservations { \n  code\n  channelId\n  channelCode\n  reason\n  jobId\n  jobState\n  jobUpdatedAt\n  jobStale\n  createdAt\n  expiresAt\n  activity\n  releasable\n  releaseRequestedAt\n  releaseCleanupJobId\n  releaseCleanupMode\n  releaseFailure {\n    code\n    message\n  }\n }\n  }\n";
+export declare const RELEASE_CHANNEL_CODE_MUTATION = "\n  mutation PlatformReleaseChannelCode($code: String!) {\n    releaseChannelCode(code: $code) {\n      code\n      outcome\n      cleanupJobId\n      cleanupMode\n      objectsRemaining\n    }\n  }\n";
+/** Where a release stands, read from the holds: still pending, or how it ended. */
+export declare function releaseStateOf(code: string, holds: readonly ChannelCodeReservation[]): {
+    state: 'pending';
+} | {
+    state: 'ended';
+    outcome: ChannelCodeReleaseOutcome;
+} | {
+    state: 'failed';
+    failure: ChannelCodeReleaseFailure;
+};
+export declare function createPlatformChannelsModule(transport: Transport, config: AdminClientConfig): PlatformChannelsModule;

package/dist/platform/channels.js

@@ -0,0 +1,128 @@
+import { BusinessRuleError, TransportError } from '@sixtyninecommerce/core';
+import { pollUntilTerminal } from '../jobs/index.js';
+import { requireHumanSession } from './guard.js';
+const RESERVATION_FIELDS = /* GraphQL */ `
+  code
+  channelId
+  channelCode
+  reason
+  jobId
+  jobState
+  jobUpdatedAt
+  jobStale
+  createdAt
+  expiresAt
+  activity
+  releasable
+  releaseRequestedAt
+  releaseCleanupJobId
+  releaseCleanupMode
+  releaseFailure {
+    code
+    message
+  }
+`;
+export const CHANNEL_CODE_RESERVATIONS_QUERY = /* GraphQL */ `
+  query PlatformChannelCodeReservations {
+    channelCodeReservations { ${RESERVATION_FIELDS} }
+  }
+`;
+export const RELEASE_CHANNEL_CODE_MUTATION = /* GraphQL */ `
+  mutation PlatformReleaseChannelCode($code: String!) {
+    releaseChannelCode(code: $code) {
+      code
+      outcome
+      cleanupJobId
+      cleanupMode
+      objectsRemaining
+    }
+  }
+`;
+const DEFAULT_WAIT_INTERVAL_MS = 5_000;
+const DEFAULT_WAIT_TIMEOUT_MS = 15 * 60_000;
+/** Where a release stands, read from the holds: still pending, or how it ended. */
+export function releaseStateOf(code, holds) {
+    const key = code.trim().toLowerCase();
+    const hold = holds.find((candidate) => candidate.code.toLowerCase() === key);
+    if (!hold)
+        return { state: 'ended', outcome: 'released' };
+    if (hold.reason === 'rename-alias')
+        return { state: 'ended', outcome: 'aliased' };
+    if (hold.releaseFailure)
+        return { state: 'failed', failure: hold.releaseFailure };
+    return { state: 'pending' };
+}
+export function createPlatformChannelsModule(transport, config) {
+    // Platform-wide: a SuperAdmin needs no tenant on the client.
+    const unscoped = (call) => ({ ...call, allowUnscoped: true });
+    async function codeReservations(options) {
+        requireHumanSession(config);
+        const data = await transport.graphql({ api: 'admin', query: CHANNEL_CODE_RESERVATIONS_QUERY }, unscoped(options));
+        return data.channelCodeReservations;
+    }
+    return {
+        codeReservations,
+        async releaseCode(code, options) {
+            requireHumanSession(config);
+            const data = await transport.graphql({ api: 'admin', query: RELEASE_CHANNEL_CODE_MUTATION, variables: { code } }, unscoped(options));
+            const wire = data.releaseChannelCode;
+            // `cleanup-started` is what an engine before the pending release answered: the cleanup it
+            // started is then NOT finished for you, so it is reported as pending and followed the same
+            // way, and `wait()` times out unless something calls the release again.
+            const pending = wire.outcome === 'pending' || wire.outcome === 'cleanup-started';
+            const ended = wire.outcome === 'released' || wire.outcome === 'aliased' ? wire.outcome : null;
+            const cleanup = pending && wire.cleanupJobId
+                ? {
+                    jobId: wire.cleanupJobId,
+                    mode: wire.cleanupMode,
+                    objectsRemaining: wire.objectsRemaining,
+                }
+                : null;
+            const runId = cleanup?.jobId ?? wire.code;
+            return {
+                code: wire.code,
+                outcome: ended ?? 'pending',
+                cleanup,
+                handle: {
+                    runId,
+                    async wait(waitOptions) {
+                        if (ended)
+                            return ended;
+                        const holds = await pollUntilTerminal({
+                            read: (signal) => codeReservations({ ...options, ...(signal ? { signal } : {}) }),
+                            isTerminal: (value) => releaseStateOf(wire.code, value).state !== 'pending',
+                            onTimeout: () => timedOut(wire.code, runId),
+                            intervalMs: DEFAULT_WAIT_INTERVAL_MS,
+                            timeoutMs: DEFAULT_WAIT_TIMEOUT_MS,
+                            ...waitOptions,
+                        });
+                        const state = releaseStateOf(wire.code, holds);
+                        if (state.state === 'ended')
+                            return state.outcome;
+                        if (state.state === 'failed')
+                            throw releaseFailed(wire.code, state.failure);
+                        throw timedOut(wire.code, runId);
+                    },
+                },
+            };
+        },
+    };
+}
+function releaseFailed(code, failure) {
+    return new BusinessRuleError({
+        code: 'CHANNEL_CODE_RELEASE_FAILED',
+        message: `The release of "${code}" did not free it (${failure.code}): ${failure.message}`,
+        status: 422,
+        service: 'vendure',
+        details: [{ code: failure.code, message: failure.message }],
+    });
+}
+function timedOut(code, runId) {
+    return new TransportError({
+        code: 'CHANNEL_CODE_RELEASE_TIMEOUT',
+        message: `Stopped waiting for the release of "${code}" (cleanup ${runId}). The engine finishes it on its own; read platform.channels.codeReservations() later to see how it ended.`,
+        status: 0,
+        service: 'vendure',
+        retryable: true,
+    });
+}

package/dist/platform/geo.d.ts

@@ -0,0 +1,123 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { AdminClientConfig } from '../client.js';
+import { type Country, type ZoneWithMembers } from '../geo/index.js';
+import type { Call } from '../types.js';
+/** A new zone, as {@link PlatformZonesModule.create} takes it. */
+export interface CreateZoneInput {
+    name: string;
+    /** The countries in it (`geo.countries.list` ids). None when left out. */
+    memberIds?: string[];
+}
+/** A change to a zone. A field left out keeps what the zone has; members have their own calls. */
+export interface UpdateZoneInput {
+    name?: string;
+}
+/** A country's name in one language. */
+export interface CountryTranslationInput {
+    /** As the engine spells it: `en`, `nl`, `pt_BR`. */
+    languageCode: string;
+    name: string;
+}
+/**
+ * A change to a country. A field left out keeps what the country has.
+ *
+ * The ISO code is not changeable here: tax class mappings, a store's ship-to list and every
+ * address carry it, so a changed code would silently re-route them.
+ */
+export interface UpdateCountryInput {
+    /**
+     * A disabled country is kept for history; checkout and address forms refuse it, in every
+     * store.
+     */
+    enabled?: boolean;
+    /** Writing a language the country has replaces that name; another language is added. */
+    translations?: CountryTranslationInput[];
+}
+/**
+ * `admin.platform.geo.zones` — the SuperAdmin writes of the platform's zones: the named sets
+ * of countries every store's tax rates and default zones point at (spec §9.2 `platform`, ruling
+ * G128). Reads are `geo.zones.list()` / `geo.zones.get()`. Every write answers the zone with its
+ * members, as `geo.zones.get()` reads it.
+ *
+ * Every method needs a human SuperAdmin session: an API token or an app credential is refused
+ * with `PLATFORM_REQUIRES_SESSION` (`PermissionDeniedError`, 403) BEFORE anything is sent, and a
+ * store administrator is refused by the engine with `PLATFORM_SETTINGS_NOT_ALLOWED`
+ * (`PermissionDeniedError`, 403) before anything is read or written. No tenant is needed on the
+ * client.
+ */
+export interface PlatformZonesModule {
+    /**
+     * Create a zone. A member id that names no country is skipped by the engine, so read the
+     * answer's `members` for what the zone holds.
+     *
+     * `INVALID_ZONE_INPUT` (`ValidationError`, 400): a missing or blank name, or `memberIds` that
+     * is not a list of ids, refused here before anything is sent.
+     *
+     * @effect write
+     */
+    create(input: CreateZoneInput, options?: Call): Promise<ZoneWithMembers>;
+    /**
+     * Rename a zone. `ENTITY_NOT_FOUND` (`NotFoundError`, 404): no zone has that id.
+     *
+     * @effect write
+     */
+    update(id: string, patch: UpdateZoneInput, options?: Call): Promise<ZoneWithMembers>;
+    /**
+     * Delete a zone.
+     *
+     * - `ZONE_NOT_DELETED` (`ConflictError`, 409): a store uses it as its default tax or shipping
+     *   zone, or a tax rate prices in it; the engine's reason names the store codes or the rates.
+     *   Nothing is deleted.
+     * - `ENTITY_NOT_FOUND` (`NotFoundError`, 404): no zone has that id.
+     *
+     * @effect destructive
+     */
+    delete(id: string, options?: Call): Promise<void>;
+    /**
+     * Add countries to a zone. A country already in it stays once, and an id that names no
+     * country is skipped by the engine: read the answer's `members` for what the zone holds.
+     *
+     * `INVALID_ZONE_INPUT` (`ValidationError`, 400): no ids, refused here. `ENTITY_NOT_FOUND`
+     * (`NotFoundError`, 404): no zone has that id.
+     *
+     * @effect write
+     */
+    addMembers(zoneId: string, memberIds: string[], options?: Call): Promise<ZoneWithMembers>;
+    /**
+     * Take countries out of a zone. An id that is not a member is ignored.
+     *
+     * `INVALID_ZONE_INPUT` (`ValidationError`, 400): no ids, refused here. `ENTITY_NOT_FOUND`
+     * (`NotFoundError`, 404): no zone has that id.
+     *
+     * @effect write
+     */
+    removeMembers(zoneId: string, memberIds: string[], options?: Call): Promise<ZoneWithMembers>;
+}
+/**
+ * `admin.platform.geo.countries` — the SuperAdmin write of the platform's countries (G128).
+ * Reads are `geo.countries.list()`. The same session rules as {@link PlatformZonesModule}.
+ */
+export interface PlatformCountriesModule {
+    /**
+     * Switch a country on or off, or rename it in a language, and answer it as read.
+     *
+     * `INVALID_COUNTRY_INPUT` (`ValidationError`, 400): an `enabled` that is not a boolean, a
+     * translation without a language or a name, or a `code` (not changeable here), refused before
+     * anything is sent. `ENTITY_NOT_FOUND` (`NotFoundError`, 404): no country has that id.
+     *
+     * @effect write
+     */
+    update(id: string, patch: UpdateCountryInput, options?: Call): Promise<Country>;
+}
+/** `admin.platform.geo`: SuperAdmin writes of the platform's zones and countries (G128). */
+export interface PlatformGeoModule {
+    zones: PlatformZonesModule;
+    countries: PlatformCountriesModule;
+}
+export declare const CREATE_ZONE_MUTATION = "\n  mutation PlatformCreateZone($input: CreateZoneInput!) {\n    createZone(input: $input) { \n  id\n  name\n  createdAt\n  updatedAt\n \n  members {\n    id\n    name\n    code\n    enabled\n    type\n  }\n }\n  }\n";
+export declare const UPDATE_ZONE_MUTATION = "\n  mutation PlatformUpdateZone($input: UpdateZoneInput!) {\n    updateZone(input: $input) { \n  id\n  name\n  createdAt\n  updatedAt\n \n  members {\n    id\n    name\n    code\n    enabled\n    type\n  }\n }\n  }\n";
+export declare const DELETE_ZONE_MUTATION = "\n  mutation PlatformDeleteZone($id: ID!) {\n    deleteZone(id: $id) { \n  result\n  message\n }\n  }\n";
+export declare const ADD_MEMBERS_TO_ZONE_MUTATION = "\n  mutation PlatformAddMembersToZone($zoneId: ID!, $memberIds: [ID!]!) {\n    addMembersToZone(zoneId: $zoneId, memberIds: $memberIds) { \n  id\n  name\n  createdAt\n  updatedAt\n \n  members {\n    id\n    name\n    code\n    enabled\n    type\n  }\n }\n  }\n";
+export declare const REMOVE_MEMBERS_FROM_ZONE_MUTATION = "\n  mutation PlatformRemoveMembersFromZone($zoneId: ID!, $memberIds: [ID!]!) {\n    removeMembersFromZone(zoneId: $zoneId, memberIds: $memberIds) { \n  id\n  name\n  createdAt\n  updatedAt\n \n  members {\n    id\n    name\n    code\n    enabled\n    type\n  }\n }\n  }\n";
+export declare const UPDATE_COUNTRY_MUTATION = "\n  mutation PlatformUpdateCountry($input: UpdateCountryInput!) {\n    updateCountry(input: $input) { \n  id\n  name\n  code\n  enabled\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare function createPlatformGeoModule(transport: Transport, config: AdminClientConfig): PlatformGeoModule;

package/dist/platform/geo.js

@@ -0,0 +1,144 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+import { assertDeleted, DELETION_FIELDS, fieldOf, } from '../catalog/types.js';
+import { COUNTRY_FIELDS, ZONE_FIELDS, ZONE_MEMBER_FIELDS, } from '../geo/index.js';
+import { requireHumanSession } from './guard.js';
+const ZONE_ANSWER = `${ZONE_FIELDS} ${ZONE_MEMBER_FIELDS}`;
+export const CREATE_ZONE_MUTATION = /* GraphQL */ `
+  mutation PlatformCreateZone($input: CreateZoneInput!) {
+    createZone(input: $input) { ${ZONE_ANSWER} }
+  }
+`;
+export const UPDATE_ZONE_MUTATION = /* GraphQL */ `
+  mutation PlatformUpdateZone($input: UpdateZoneInput!) {
+    updateZone(input: $input) { ${ZONE_ANSWER} }
+  }
+`;
+export const DELETE_ZONE_MUTATION = /* GraphQL */ `
+  mutation PlatformDeleteZone($id: ID!) {
+    deleteZone(id: $id) { ${DELETION_FIELDS} }
+  }
+`;
+export const ADD_MEMBERS_TO_ZONE_MUTATION = /* GraphQL */ `
+  mutation PlatformAddMembersToZone($zoneId: ID!, $memberIds: [ID!]!) {
+    addMembersToZone(zoneId: $zoneId, memberIds: $memberIds) { ${ZONE_ANSWER} }
+  }
+`;
+export const REMOVE_MEMBERS_FROM_ZONE_MUTATION = /* GraphQL */ `
+  mutation PlatformRemoveMembersFromZone($zoneId: ID!, $memberIds: [ID!]!) {
+    removeMembersFromZone(zoneId: $zoneId, memberIds: $memberIds) { ${ZONE_ANSWER} }
+  }
+`;
+export const UPDATE_COUNTRY_MUTATION = /* GraphQL */ `
+  mutation PlatformUpdateCountry($input: UpdateCountryInput!) {
+    updateCountry(input: $input) { ${COUNTRY_FIELDS} }
+  }
+`;
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const refusal = (code) => (message) => new ValidationError({ code, message, status: 400, service: 'vendure' });
+const zoneRefusal = refusal('INVALID_ZONE_INPUT');
+const countryRefusal = refusal('INVALID_COUNTRY_INPUT');
+const isId = (value) => typeof value === 'string' && value.trim() !== '';
+function requireId(id, what, refuse) {
+    if (!isId(id))
+        throw refuse(`${what} must be an id.`);
+    return id;
+}
+function memberIdsInput(value, allowEmpty) {
+    if (!Array.isArray(value) || !value.every(isId)) {
+        throw zoneRefusal('memberIds must be a list of country ids.');
+    }
+    if (!allowEmpty && value.length === 0) {
+        throw zoneRefusal('Name at least one country.');
+    }
+    return [...value];
+}
+function zoneInput(input, creating) {
+    if (!isObject(input))
+        throw zoneRefusal('A zone input must be an object.');
+    const out = {};
+    if (input.name !== undefined || creating) {
+        if (typeof input.name !== 'string' || input.name.trim() === '') {
+            throw zoneRefusal('A zone needs a name.');
+        }
+        out.name = input.name;
+    }
+    if (creating && input.memberIds !== undefined) {
+        out.memberIds = memberIdsInput(input.memberIds, true);
+    }
+    return out;
+}
+function countryInput(input) {
+    if (!isObject(input))
+        throw countryRefusal('A country change must be an object.');
+    if (input.code !== undefined) {
+        throw countryRefusal('A country keeps its ISO code: tax class mappings, ship-to lists and addresses carry it.');
+    }
+    const out = {};
+    if (input.enabled !== undefined) {
+        if (typeof input.enabled !== 'boolean')
+            throw countryRefusal('enabled must be a boolean.');
+        out.enabled = input.enabled;
+    }
+    if (input.translations !== undefined) {
+        const rows = input.translations;
+        if (!Array.isArray(rows) ||
+            !rows.every((row) => isObject(row) &&
+                typeof row.languageCode === 'string' &&
+                row.languageCode !== '' &&
+                typeof row.name === 'string' &&
+                row.name.trim() !== '')) {
+            throw countryRefusal('translations must be a list of { languageCode, name } with strings.');
+        }
+        out.translations = rows.map((row) => ({
+            languageCode: row.languageCode,
+            name: row.name,
+        }));
+    }
+    return out;
+}
+export function createPlatformGeoModule(transport, config) {
+    // Platform-wide rows: no store is involved, so no tenant is needed. Scoped to a store instead,
+    // the transport would first resolve it through the CMS channel mirror and fail on one missing
+    // there.
+    const unscoped = (call) => ({ ...call, allowUnscoped: true });
+    return {
+        zones: {
+            async create(input, options) {
+                requireHumanSession(config);
+                return fieldOf(transport, CREATE_ZONE_MUTATION, 'createZone', { input: zoneInput(input, true) }, unscoped(options));
+            },
+            async update(id, patch, options) {
+                requireHumanSession(config);
+                const zoneId = requireId(id, 'id', zoneRefusal);
+                return fieldOf(transport, UPDATE_ZONE_MUTATION, 'updateZone', { input: { ...zoneInput(patch, false), id: zoneId } }, unscoped(options));
+            },
+            async delete(id, options) {
+                requireHumanSession(config);
+                assertDeleted('ZONE_NOT_DELETED', [
+                    await fieldOf(transport, DELETE_ZONE_MUTATION, 'deleteZone', { id: requireId(id, 'id', zoneRefusal) }, unscoped(options)),
+                ]);
+            },
+            async addMembers(zoneId, memberIds, options) {
+                requireHumanSession(config);
+                return fieldOf(transport, ADD_MEMBERS_TO_ZONE_MUTATION, 'addMembersToZone', {
+                    zoneId: requireId(zoneId, 'zoneId', zoneRefusal),
+                    memberIds: memberIdsInput(memberIds, false),
+                }, unscoped(options));
+            },
+            async removeMembers(zoneId, memberIds, options) {
+                requireHumanSession(config);
+                return fieldOf(transport, REMOVE_MEMBERS_FROM_ZONE_MUTATION, 'removeMembersFromZone', {
+                    zoneId: requireId(zoneId, 'zoneId', zoneRefusal),
+                    memberIds: memberIdsInput(memberIds, false),
+                }, unscoped(options));
+            },
+        },
+        countries: {
+            async update(id, patch, options) {
+                requireHumanSession(config);
+                const countryId = requireId(id, 'id', countryRefusal);
+                return fieldOf(transport, UPDATE_COUNTRY_MUTATION, 'updateCountry', { input: { ...countryInput(patch), id: countryId } }, unscoped(options));
+            },
+        },
+    };
+}