@sixtyninecommerce/admin 0.10.0 → 0.11.0

package/dist/orders/plan-edit.js

@@ -1,3 +1,4 @@
+import { storeCreditAware } from '../payments/store-credit-fields.js';
 /**
  * Its own document on purpose: `planOrderEdit` exists only on an engine with
  * the order-edit plan, so on an older one this call alone fails validation and
@@ -26,11 +27,13 @@ export const PLAN_ORDER_EDIT_QUERY = /* GraphQL */ `
           available
           code
           message
+          book
         }
         accountCredit {
           available
           code
           message
+          book
         }
         refundWhenChosen {
           paymentId
@@ -77,7 +80,7 @@ export const PLAN_ORDER_EDIT_QUERY = /* GraphQL */ `
 export function createOrderPlanEditModule(transport) {
     return {
         async planEdit(orderId, diff, options) {
-            const data = await transport.graphql({
+            const data = await storeCreditAware(transport).graphql({
                 api: 'admin',
                 query: PLAN_ORDER_EDIT_QUERY,
                 // The diff goes out as given, never normalised: `orderDiscount` left

package/dist/orders/settings.d.ts

@@ -0,0 +1,201 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { SettingsSourceKind } from '../tenant/settings-sources.js';
+import type { Call } from '../types.js';
+/** The states an order status rule may move a placed order to. */
+export declare const ORDER_STATUS_RULE_TARGET_STATES: readonly ["AwaitingApproval", "PaymentAuthorized", "PaymentSettled"];
+/** What an order status rule matches on. */
+export declare const ORDER_STATUS_RULE_CONDITION_TYPES: readonly ["product", "coupon", "collection", "facet_value"];
+/** The fewest zero-padded digits of a sequential order number. */
+export declare const ORDER_CODE_DIGITS_MIN = 4;
+/** The most zero-padded digits of a sequential order number. */
+export declare const ORDER_CODE_DIGITS_MAX = 8;
+/**
+ * The longest order-number prefix. The engine stores more, but every order code is
+ * `NAMESPACE-PREFIX00001` in a 255-character column: a long prefix fails EVERY order placement.
+ */
+export declare const ORDER_CODE_PREFIX_MAX_LENGTH = 20;
+/** The youngest minimum purchase age (the engine checks no age below 1: `minimumAge > 0`). */
+export declare const MINIMUM_AGE_MIN = 1;
+/** The oldest minimum purchase age the platform accepts. */
+export declare const MINIMUM_AGE_MAX = 99;
+/**
+ * The largest amount (minor units) the minimum and the thresholds hold: the columns are Vendure
+ * `int` custom fields, GraphQL `Int` (32 bits). ₩30,000,000 is 3,000,000,000 hundredths, past it.
+ */
+export declare const ORDER_SETTINGS_AMOUNT_MAX = 2147483647;
+export type OrderStatusRuleTargetState = (typeof ORDER_STATUS_RULE_TARGET_STATES)[number];
+export type OrderStatusRuleConditionType = (typeof ORDER_STATUS_RULE_CONDITION_TYPES)[number];
+/**
+ * A rule that moves an order into `targetState` on its FIRST placement when it matches. Rules run
+ * in array order and the first enabled match wins; a rule whose list for its `conditionType` is
+ * empty never fires.
+ */
+export interface OrderStatusRule {
+    id: string;
+    /** For people only. `''` for a stored rule that has none: the engine fires it all the same. */
+    name: string;
+    targetState: OrderStatusRuleTargetState;
+    conditionType: OrderStatusRuleConditionType;
+    /** Read for `product`. */
+    productVariantIds?: string[];
+    /** Read for `coupon`, compared without case. */
+    couponCodes?: string[];
+    /** Read for `collection`. */
+    collectionIds?: string[];
+    /** Read for `facet_value`. */
+    facetValueIds?: string[];
+    enabled: boolean;
+}
+/** Where the minimum purchase age the engine applies comes from (`settings.age_verification`). */
+export interface MinimumAgeSource {
+    /** `channel`: the store's own `minimumAge`; `organization`: its organization's. */
+    source: SettingsSourceKind | (string & {});
+    /**
+     * The organization locked the group: {@link OrderSettingsModule.set} refuses a changed
+     * `minimumAge` with `MANAGED_BY_ORGANIZATION`, SuperAdmins included.
+     */
+    locked: boolean;
+    /** The organization shares the group without locking it. */
+    inheritable: boolean;
+    /** The store keeps its own value although the organization shares the group. */
+    overridden: boolean;
+    /** The age the engine applies to this store's checkout; null when none. */
+    effective: number | null;
+}
+/**
+ * The ACTIVE store's order settings, as its channel stores them. Every amount is in minor units
+ * (hundredths, for every currency: ¥5,000 is 500000, as the platform stores all money) of
+ * {@link OrderSettings.currencyCode}, the store's default currency.
+ */
+export interface OrderSettings {
+    /** The store these are the settings of (its channel id). */
+    channelId: string;
+    /** The store's default currency (ISO 4217): the minimum and both thresholds are in it. */
+    currencyCode: string;
+    /**
+     * The least an order may cost (with tax) before it can be placed; null when there is no
+     * minimum. An order in another currency is held to it converted at the checkout's rate.
+     */
+    minOrderAmount: number | null;
+    /** Customer groups whose members are not held to the minimum. */
+    exemptCustomerGroupIds: string[];
+    /** Collections whose items do not count toward the minimum. */
+    exemptCollectionIds: string[];
+    /** Placed orders get sequential numbers (`NAMESPACE-PREFIX00001`); off: random codes. */
+    orderCodeEnabled: boolean;
+    /**
+     * The store's part of every sequential order number, set by the platform (from the store's
+     * code) and never by a caller; read-only here. Null until sequential numbers were first on.
+     */
+    orderCodeNamespace: string | null;
+    /** The merchant's part after the namespace, e.g. `VIN-`; null for none. */
+    orderCodePrefix: string | null;
+    /** How many zero-padded digits the number has, 4 to 8; null is the platform's 5. */
+    orderCodeDigits: number | null;
+    /**
+     * The store's OWN minimum purchase age, what {@link OrderSettingsModule.set} writes; null for
+     * none. While the store takes `settings.age_verification` from its organization the engine
+     * applies the organization's instead: see {@link OrderSettings.minimumAgeSource}.
+     */
+    minimumAge: number | null;
+    minimumAgeSource: MinimumAgeSource;
+    /**
+     * The rules the engine applies, read as the engine reads them: an entry without a string `id`,
+     * a known `targetState` and a known `conditionType` is left out (the engine never fires it);
+     * a rule without a name reads `name: ''`, its `enabled` as the engine takes it, and its lists
+     * as their non-empty strings.
+     */
+    orderStatusRules: OrderStatusRule[];
+    /** A customer's balance above this shows as a warning; null for no warning tier. */
+    outstandingBalanceWarningThreshold: number | null;
+    /** A customer's balance above this shows as critical; null for no critical tier. */
+    outstandingBalanceCriticalThreshold: number | null;
+}
+/**
+ * A PATCH of {@link OrderSettings}: a key left out is unchanged, `null` clears it. At least one
+ * key. There is no `orderCodeNamespace`: the platform sets it (ruling G125).
+ */
+export interface UpdateOrderSettingsInput {
+    /** Whole minor units, 0 to {@link ORDER_SETTINGS_AMOUNT_MAX}; null for no minimum. */
+    minOrderAmount?: number | null;
+    /** The whole list (it replaces the stored one); empty for none. */
+    exemptCustomerGroupIds?: string[];
+    /** The whole list (it replaces the stored one); empty for none. */
+    exemptCollectionIds?: string[];
+    /**
+     * Switching it on for a store that never had sequential numbers also sets its namespace to the
+     * store's code in capitals, as provisioning does for a new store.
+     */
+    orderCodeEnabled?: boolean;
+    /** At most 20 characters; null for none. */
+    orderCodePrefix?: string | null;
+    /** A whole number from 4 to 8; null for the platform's 5. */
+    orderCodeDigits?: number | null;
+    /** A whole number of years from 1 to 99; null for no age check. */
+    minimumAge?: number | null;
+    /** The whole list, in priority order (it replaces the stored one); empty for none. */
+    orderStatusRules?: OrderStatusRule[];
+    /** Whole minor units, 0 to {@link ORDER_SETTINGS_AMOUNT_MAX}; null for no warning tier. */
+    outstandingBalanceWarningThreshold?: number | null;
+    /** Whole minor units, 0 to {@link ORDER_SETTINGS_AMOUNT_MAX}; null for no critical tier. */
+    outstandingBalanceCriticalThreshold?: number | null;
+}
+/**
+ * `admin.orders.settings`: the ACTIVE store's order settings (Settings → Orders): its order
+ * minimum and who is exempt from it, how its orders are numbered, the minimum purchase age, the
+ * rules that route a placed order into a state, and the outstanding-balance warning tiers. Stored
+ * as Channel custom fields; written through core `updateChannel` (typed per domain, ruling G80).
+ *
+ * The deposit policy (`orders.depositPolicy`) and the fulfilment payment policy
+ * (`fulfillments.paymentPolicy`) have doors of their own.
+ */
+export interface OrderSettingsModule {
+    /**
+     * The settings as the engine applies them, with where the minimum age comes from. Reading
+     * needs an administrator of the store with any permission beyond `Authenticated`.
+     *
+     * @effect read
+     */
+    get(options?: Call): Promise<OrderSettings>;
+    /**
+     * Change the settings `patch` names, and answer them all as the engine now stores them.
+     *
+     * Changing the minimum or its exemptions changes which orders the store accepts from the next
+     * checkout on; orders already placed keep the rule they were placed under.
+     *
+     * **Coded refusals:**
+     * - `ORDER_SETTINGS_INVALID` → {@link ValidationError} (400), before any request: an empty
+     *   patch; a key that is not an order setting (`orderCodeNamespace` included: the platform
+     *   sets it); an amount that is not a whole number of minor units from 0 to
+     *   {@link ORDER_SETTINGS_AMOUNT_MAX} (the column is a 32-bit `Int`); digits outside
+     *   4–8; a prefix longer than 20 characters; an age outside 1–99; a list that is not an array.
+     *   One `details[]` entry per failing key, `field` naming it.
+     * - `CHANNEL_SETTINGS_INVALID` → {@link ValidationError} (400), from the engine: an exemption
+     *   list that is not distinct non-empty ids (at most 255 characters encoded, about six ids),
+     *   a malformed status rule, or a critical threshold not above the warning threshold
+     *   (`code: 'MUST_EXCEED_WARNING'`). `details[].field` is the input path, such as
+     *   `customFields.outstandingBalanceCriticalThreshold`; `details[].message` is the engine's
+     *   sentence, with the amounts in the store's currency.
+     * - `MANAGED_BY_ORGANIZATION` → `BusinessRuleError` (422): a changed `minimumAge` while the
+     *   organization locks `settings.age_verification`.
+     * - `ORGANIZATION_SETTINGS_INHERITED` → `BusinessRuleError` (422): a changed `minimumAge`
+     *   while the store inherits the group; `tenant.settingsSources.override` it first. Sending
+     *   the stored value back unchanged is accepted and changes nothing.
+     * - `FORBIDDEN` → `PermissionDeniedError` (403): the credential lacks `UpdateChannel`.
+     *
+     * @effect write
+     * @permission UpdateChannel
+     */
+    set(patch: UpdateOrderSettingsInput, options?: Call): Promise<OrderSettings>;
+}
+export declare const ORDER_SETTINGS_QUERY = "\n  query OrderSettings {\n    activeChannel { \n  id\n  code\n  defaultCurrencyCode\n  customFields {\n    minOrderAmount\n    exemptCustomerGroupIds\n    exemptCollectionIds\n    orderCodeNamespace\n    orderCodePrefix\n    orderCodeDigits\n    orderCodeEnabled\n    minimumAge\n    orderStatusRules\n    outstandingBalanceWarningThreshold\n    outstandingBalanceCriticalThreshold\n  }\n }\n    channelSettingsSources { group source locked overridden inheritable values }\n  }\n";
+export declare const UPDATE_ORDER_SETTINGS_MUTATION = "\n  mutation UpdateOrderSettings($input: UpdateChannelInput!) {\n    updateChannel(input: $input) {\n      ... on Channel { \n  id\n  code\n  defaultCurrencyCode\n  customFields {\n    minOrderAmount\n    exemptCustomerGroupIds\n    exemptCollectionIds\n    orderCodeNamespace\n    orderCodePrefix\n    orderCodeDigits\n    orderCodeEnabled\n    minimumAge\n    orderStatusRules\n    outstandingBalanceWarningThreshold\n    outstandingBalanceCriticalThreshold\n  }\n }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
+/**
+ * The column as the engine's `parseRules` keeps it: an entry with a string `id`, a known
+ * `targetState` and a known `conditionType`. A rule the engine keeps is never dropped here (a
+ * stricter reader would erase it on the next save, turning off the transition it performs), so
+ * a missing `name` reads `''` and `enabled` reads as the engine takes it (truthy fires). Only the
+ * rule's own keys come back, so the list can be sent back as the engine's schema wants it.
+ */
+export declare function readOrderStatusRules(raw: unknown): OrderStatusRule[];
+export declare function createOrderSettingsModule(transport: Transport): OrderSettingsModule;

package/dist/orders/settings.js

@@ -0,0 +1,325 @@
+import { errorFromErrorResult, isErrorResult, NotFoundError, ValidationError, } from '@sixtyninecommerce/core';
+// Mirrors, pinned by `__tests__/order-settings.spec.ts`: the engine's `VALID_TARGET_STATES` /
+// `VALID_CONDITION_TYPES` (`order-constraints/order-status-rules-process.ts`) and the shared
+// `ORDER_STATUS_RULE_*` the meta catalog publishes; `ORDER_CODE_DIGITS_MIN/MAX` in
+// `order-code/channel-aware-order-code-strategy.ts`. Change both sides together.
+/** The states an order status rule may move a placed order to. */
+export const ORDER_STATUS_RULE_TARGET_STATES = [
+    'AwaitingApproval',
+    'PaymentAuthorized',
+    'PaymentSettled',
+];
+/** What an order status rule matches on. */
+export const ORDER_STATUS_RULE_CONDITION_TYPES = [
+    'product',
+    'coupon',
+    'collection',
+    'facet_value',
+];
+/** The fewest zero-padded digits of a sequential order number. */
+export const ORDER_CODE_DIGITS_MIN = 4;
+/** The most zero-padded digits of a sequential order number. */
+export const ORDER_CODE_DIGITS_MAX = 8;
+/**
+ * The longest order-number prefix. The engine stores more, but every order code is
+ * `NAMESPACE-PREFIX00001` in a 255-character column: a long prefix fails EVERY order placement.
+ */
+export const ORDER_CODE_PREFIX_MAX_LENGTH = 20;
+/** The youngest minimum purchase age (the engine checks no age below 1: `minimumAge > 0`). */
+export const MINIMUM_AGE_MIN = 1;
+/** The oldest minimum purchase age the platform accepts. */
+export const MINIMUM_AGE_MAX = 99;
+/**
+ * The largest amount (minor units) the minimum and the thresholds hold: the columns are Vendure
+ * `int` custom fields, GraphQL `Int` (32 bits). ₩30,000,000 is 3,000,000,000 hundredths, past it.
+ */
+export const ORDER_SETTINGS_AMOUNT_MAX = 2_147_483_647;
+/** The settings group `minimumAge` belongs to (multi-region spec §5.3). */
+const AGE_GROUP = 'settings.age_verification';
+const CHANNEL_FIELDS = /* GraphQL */ `
+  id
+  code
+  defaultCurrencyCode
+  customFields {
+    minOrderAmount
+    exemptCustomerGroupIds
+    exemptCollectionIds
+    orderCodeNamespace
+    orderCodePrefix
+    orderCodeDigits
+    orderCodeEnabled
+    minimumAge
+    orderStatusRules
+    outstandingBalanceWarningThreshold
+    outstandingBalanceCriticalThreshold
+  }
+`;
+export const ORDER_SETTINGS_QUERY = /* GraphQL */ `
+  query OrderSettings {
+    activeChannel { ${CHANNEL_FIELDS} }
+    channelSettingsSources { group source locked overridden inheritable values }
+  }
+`;
+export const UPDATE_ORDER_SETTINGS_MUTATION = /* GraphQL */ `
+  mutation UpdateOrderSettings($input: UpdateChannelInput!) {
+    updateChannel(input: $input) {
+      ... on Channel { ${CHANNEL_FIELDS} }
+      ... on ErrorResult { errorCode message }
+    }
+  }
+`;
+const INVALID = 'ORDER_SETTINGS_INVALID';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isWhole = (value) => typeof value === 'number' && Number.isSafeInteger(value);
+const numberOrNull = (value) => typeof value === 'number' && Number.isFinite(value) ? value : null;
+const stringOrNull = (value) => (typeof value === 'string' ? value : null);
+/** The non-empty strings of `value`, when it is an array; otherwise none. */
+function strings(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string' && item.length > 0)
+        : [];
+}
+function parsedJson(raw) {
+    if (typeof raw !== 'string' || raw === '')
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * An exemption list as the order-minimum checker reads it: the column's non-empty string ids,
+ * once each; anything unreadable is no exemption.
+ */
+function readIdList(raw) {
+    return [...new Set(strings(parsedJson(raw)))];
+}
+const LIST_OF = {
+    product: 'productVariantIds',
+    coupon: 'couponCodes',
+    collection: 'collectionIds',
+    facet_value: 'facetValueIds',
+};
+const TARGET_STATES = new Set(ORDER_STATUS_RULE_TARGET_STATES);
+const CONDITION_TYPES = new Set(ORDER_STATUS_RULE_CONDITION_TYPES);
+/**
+ * The column as the engine's `parseRules` keeps it: an entry with a string `id`, a known
+ * `targetState` and a known `conditionType`. A rule the engine keeps is never dropped here (a
+ * stricter reader would erase it on the next save, turning off the transition it performs), so
+ * a missing `name` reads `''` and `enabled` reads as the engine takes it (truthy fires). Only the
+ * rule's own keys come back, so the list can be sent back as the engine's schema wants it.
+ */
+export function readOrderStatusRules(raw) {
+    const parsed = parsedJson(raw);
+    if (!Array.isArray(parsed))
+        return [];
+    const rules = [];
+    for (const entry of parsed) {
+        if (!isRecord(entry))
+            continue;
+        const { id, targetState, conditionType } = entry;
+        if (typeof id !== 'string' || !TARGET_STATES.has(targetState))
+            continue;
+        if (!CONDITION_TYPES.has(conditionType))
+            continue;
+        const rule = {
+            id,
+            name: typeof entry.name === 'string' ? entry.name : '',
+            targetState: targetState,
+            conditionType: conditionType,
+            enabled: Boolean(entry.enabled),
+        };
+        for (const list of Object.values(LIST_OF)) {
+            if (Array.isArray(entry[list]))
+                rule[list] = strings(entry[list]);
+        }
+        rules.push(rule);
+    }
+    return rules;
+}
+/** An age the engine checks (`minimumAge > 0`), else none. */
+const checkedAge = (age) => (age !== null && age > 0 ? age : null);
+function sourceOf(sources, own) {
+    const group = sources.find((item) => item.group === AGE_GROUP);
+    if (!group) {
+        return {
+            source: 'channel',
+            locked: false,
+            inheritable: false,
+            overridden: false,
+            effective: checkedAge(own),
+        };
+    }
+    // The store's own value when its own applies: after `set` the sources are the ones read BEFORE
+    // the write, so their values would answer the old age. The organization's values otherwise.
+    const applied = group.source !== 'channel' && group.values ? numberOrNull(group.values.minimumAge) : own;
+    return {
+        source: group.source,
+        locked: group.locked,
+        inheritable: group.inheritable,
+        overridden: group.overridden,
+        effective: checkedAge(applied),
+    };
+}
+function settingsOf(channel, sources) {
+    const fields = channel.customFields ?? {};
+    const minimumAge = numberOrNull(fields.minimumAge);
+    return {
+        channelId: channel.id,
+        currencyCode: channel.defaultCurrencyCode,
+        minOrderAmount: numberOrNull(fields.minOrderAmount),
+        exemptCustomerGroupIds: readIdList(fields.exemptCustomerGroupIds),
+        exemptCollectionIds: readIdList(fields.exemptCollectionIds),
+        orderCodeEnabled: fields.orderCodeEnabled === true,
+        orderCodeNamespace: stringOrNull(fields.orderCodeNamespace) || null,
+        orderCodePrefix: stringOrNull(fields.orderCodePrefix),
+        orderCodeDigits: numberOrNull(fields.orderCodeDigits),
+        minimumAge,
+        minimumAgeSource: sourceOf(sources, minimumAge),
+        orderStatusRules: readOrderStatusRules(fields.orderStatusRules),
+        outstandingBalanceWarningThreshold: numberOrNull(fields.outstandingBalanceWarningThreshold),
+        outstandingBalanceCriticalThreshold: numberOrNull(fields.outstandingBalanceCriticalThreshold),
+    };
+}
+const PATCH_KEYS = [
+    'minOrderAmount',
+    'exemptCustomerGroupIds',
+    'exemptCollectionIds',
+    'orderCodeEnabled',
+    'orderCodePrefix',
+    'orderCodeDigits',
+    'minimumAge',
+    'orderStatusRules',
+    'outstandingBalanceWarningThreshold',
+    'outstandingBalanceCriticalThreshold',
+];
+const KNOWN_KEYS = new Set(PATCH_KEYS);
+const AMOUNT_KEYS = [
+    'minOrderAmount',
+    'outstandingBalanceWarningThreshold',
+    'outstandingBalanceCriticalThreshold',
+];
+const LIST_KEYS = ['exemptCustomerGroupIds', 'exemptCollectionIds', 'orderStatusRules'];
+/** Every way `patch` breaks the input's shape, one entry per key. */
+function problemsOf(patch) {
+    const problems = [];
+    const add = (field, message) => problems.push({ field, code: INVALID, message });
+    if (!isRecord(patch)) {
+        add('patch', 'Pass the settings to change as an object, e.g. { minOrderAmount: 5000 }.');
+        return problems;
+    }
+    const named = Object.keys(patch).filter((key) => patch[key] !== undefined);
+    if (named.length === 0) {
+        add('patch', `Name at least one setting to change: ${PATCH_KEYS.join(', ')}.`);
+    }
+    for (const key of named) {
+        if (KNOWN_KEYS.has(key))
+            continue;
+        add(key, key === 'orderCodeNamespace'
+            ? 'orderCodeNamespace is set by the platform from the store code, never by a caller: switch orderCodeEnabled on and it is set for you.'
+            : `${key} is not an order setting; the settings are ${PATCH_KEYS.join(', ')}.`);
+    }
+    for (const key of AMOUNT_KEYS) {
+        const value = patch[key];
+        if (value === undefined || value === null)
+            continue;
+        if (!(isWhole(value) && value >= 0 && value <= ORDER_SETTINGS_AMOUNT_MAX)) {
+            add(key, `${key} must be a whole number of minor units from 0 to ${String(ORDER_SETTINGS_AMOUNT_MAX)}, or null to clear it.`);
+        }
+    }
+    for (const key of LIST_KEYS) {
+        const value = patch[key];
+        if (value !== undefined && !Array.isArray(value)) {
+            add(key, `${key} must be an array (the whole list); send [] for none.`);
+        }
+    }
+    if (patch.orderCodeEnabled !== undefined && typeof patch.orderCodeEnabled !== 'boolean') {
+        add('orderCodeEnabled', 'orderCodeEnabled must be true or false.');
+    }
+    const prefix = patch.orderCodePrefix;
+    if (prefix !== undefined &&
+        prefix !== null &&
+        !(typeof prefix === 'string' && prefix.length <= ORDER_CODE_PREFIX_MAX_LENGTH)) {
+        add('orderCodePrefix', `orderCodePrefix must be text of at most ${String(ORDER_CODE_PREFIX_MAX_LENGTH)} characters, or null for none.`);
+    }
+    const digits = patch.orderCodeDigits;
+    if (digits !== undefined &&
+        digits !== null &&
+        !(isWhole(digits) && digits >= ORDER_CODE_DIGITS_MIN && digits <= ORDER_CODE_DIGITS_MAX)) {
+        add('orderCodeDigits', `orderCodeDigits must be a whole number from ${String(ORDER_CODE_DIGITS_MIN)} to ${String(ORDER_CODE_DIGITS_MAX)}, or null for the default.`);
+    }
+    const age = patch.minimumAge;
+    if (age !== undefined &&
+        age !== null &&
+        !(isWhole(age) && age >= MINIMUM_AGE_MIN && age <= MINIMUM_AGE_MAX)) {
+        add('minimumAge', `minimumAge must be a whole number of years from ${String(MINIMUM_AGE_MIN)} to ${String(MINIMUM_AGE_MAX)}, or null for no age check.`);
+    }
+    return problems;
+}
+/** A list column as the engine stores it: JSON text, or null for an empty list. */
+const listColumn = (list) => list.length > 0 ? JSON.stringify(list) : null;
+/** The custom fields `patch` writes; `before` is the store as read just before. */
+function customFieldsOf(patch, before) {
+    const fields = {};
+    for (const key of PATCH_KEYS) {
+        const value = patch[key];
+        if (value === undefined)
+            continue;
+        fields[key] = Array.isArray(value) ? listColumn(value) : value;
+    }
+    // Ruling G125: the namespace is the platform's, never the caller's. A store switching
+    // sequential numbers on for the first time gets its code in capitals, which is what
+    // provisioning gives a new store (`provision-store.saga.ts`) and is unique because codes are.
+    const namespace = stringOrNull(before.customFields?.orderCodeNamespace);
+    if (patch.orderCodeEnabled === true && !namespace) {
+        fields.orderCodeNamespace = before.code.toUpperCase();
+    }
+    return fields;
+}
+export function createOrderSettingsModule(transport) {
+    const read = async (options) => {
+        const data = await transport.graphql({ api: 'admin', query: ORDER_SETTINGS_QUERY }, options);
+        if (!data.activeChannel) {
+            throw new NotFoundError({
+                code: 'CHANNEL_NOT_FOUND',
+                message: 'No store is active for this session, so it has no order settings to read.',
+                status: 404,
+                service: 'vendure',
+            });
+        }
+        return { channel: data.activeChannel, sources: data.channelSettingsSources ?? [] };
+    };
+    return {
+        async get(options) {
+            const { channel, sources } = await read(options);
+            return settingsOf(channel, sources);
+        },
+        async set(patch, options) {
+            const problems = problemsOf(patch);
+            if (problems.length > 0) {
+                throw new ValidationError({
+                    code: INVALID,
+                    message: problems.map((problem) => problem.message).join(' '),
+                    status: 400,
+                    service: 'vendure',
+                    details: problems,
+                });
+            }
+            // The id `updateChannel` needs and the namespace rule's "before", read with the SAME call
+            // options, so a per-call tenant writes its own store rather than the client's.
+            const { channel, sources } = await read(options);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: UPDATE_ORDER_SETTINGS_MUTATION,
+                variables: { input: { id: channel.id, customFields: customFieldsOf(patch, channel) } },
+            }, options);
+            if (isErrorResult(data.updateChannel))
+                throw errorFromErrorResult(data.updateChannel);
+            // An order settings write never changes where the age comes from, so the sources read
+            // just before still hold; `sourceOf` takes the new own value when the store's applies.
+            return settingsOf(data.updateChannel, sources);
+        },
+    };
+}