@sixtyninecommerce/admin 0.11.0 → 0.12.0

package/dist/seo/redirects.d.ts

@@ -18,10 +18,135 @@ export interface RedirectCreateInput {
     statusCode?: number;
 }
 export type RedirectUpdateInput = Partial<RedirectCreateInput>;
+/**
+ * The most rows one {@link RedirectsModule.import} takes. Mirrors `ArrayMaxSize` on the plugins
+ * service's `ImportRedirectsDto` (`services/plugins/src/redirects/dto/import-redirects.dto.ts`),
+ * pinned by `__tests__/redirects.spec.ts`. Change both sides together.
+ */
+export declare const REDIRECT_IMPORT_MAX_ROWS = 5000;
+/**
+ * How long an import may take before the call gives up, unless the caller says otherwise: the
+ * service saves the rows one by one, and a full batch takes far longer than a single write.
+ */
+export declare const REDIRECT_IMPORT_TIMEOUT_MS = 60000;
+/**
+ * One row of {@link RedirectsModule.import}. Not checked before sending: the service judges each
+ * row on its own and reports a bad one in {@link RedirectImportResult.rejected}, so a malformed
+ * row never costs the rest of the batch.
+ */
+export interface RedirectImportRow {
+    /** One exact path, e.g. `/product/old-slug`. */
+    oldPath: string;
+    /** A path, or an absolute `https://` URL. */
+    newPath: string;
+    /** 301 (the default), 302, 303, 307 or 308. */
+    statusCode?: number;
+}
+/** A row the service refused, and why. The other rows still landed. */
+export interface RedirectImportRejection {
+    /** The row's position in the array sent, from 0. */
+    index: number;
+    /** The row's source path as sent. */
+    oldPath: string;
+    /**
+     * The service's sentence for the person fixing the file: a source that is not one exact path,
+     * a destination that is neither a path nor an `https://` URL, a status code outside the five,
+     * a source that redirects to itself, or a row that would close a redirect loop or a chain past
+     * the hop limit (with the rows already stored or with an earlier row of the same batch). There
+     * is no code per row yet.
+     */
+    message: string;
+}
+/**
+ * What an import did. A row whose source the store already redirects UPDATES that redirect
+ * (same source, so never a duplicate); any other accepted row creates one.
+ */
+export interface RedirectImportResult {
+    created: number;
+    updated: number;
+    /** Empty when every row landed. */
+    rejected: RedirectImportRejection[];
+}
+/**
+ * `admin.seo.redirects` — the ACTIVE store's URL redirects, on the plugins service. Storefronts read
+ * the same rows live from the public redirect map (`@sixtyninecommerce/client/next`'s
+ * `createRedirectMiddleware`), so a write here changes what the store's old URLs answer within a
+ * few minutes, with no deployment.
+ *
+ * Every method needs `UpdateChannel` (`FORBIDDEN` → `PermissionDeniedError`, 403, otherwise). The
+ * writes that set up a redirect (`create`, `update`, `import`) are refused in an organization's
+ * workspace with `ORGANIZATION_WORKSPACE_NOT_A_STORE` (`BusinessRuleError`, 422): a workspace has
+ * no storefront. Removing one is never refused there.
+ */
 export interface RedirectsModule {
+    /**
+     * The store's redirects, newest first, a page at a time (`limit` 1 to 200; 50 by default).
+     * Iterate the page (`for await`) to walk every page.
+     *
+     * @effect read
+     * @permission UpdateChannel
+     */
     list(options?: ListOptions): Promise<Page<Redirect>>;
+    /**
+     * Add one redirect. The service applies the same path rules as `import`: a malformed path, a
+     * self-redirect or a status code outside the five is `ValidationError` (400); a source the store
+     * already redirects, a loop, or a chain past the service's hop limit is `ConflictError` (409).
+     * The idempotency key is honoured: a repeat answers the first response.
+     *
+     * @effect write
+     * @permission UpdateChannel
+     */
     create(input: RedirectCreateInput, options?: Call): Promise<Redirect>;
+    /**
+     * Change the fields `input` names; at least one. The same rules as `create`; an unknown id is
+     * `NotFoundError` (404).
+     *
+     * @effect write
+     * @permission UpdateChannel
+     */
     update(id: string, input: RedirectUpdateInput, options?: Call): Promise<Redirect>;
+    /**
+     * Remove one redirect: the old URL stops redirecting once the storefront's copy of the map
+     * expires. An unknown id is `NotFoundError` (404).
+     *
+     * @effect destructive
+     * @permission UpdateChannel
+     */
     delete(id: string, options?: Call): Promise<void>;
+    /**
+     * Add or update up to {@link REDIRECT_IMPORT_MAX_ROWS} redirects in one call, matched on the
+     * source path (a source the store already redirects is updated, never duplicated). Each row is
+     * judged on its own: a bad one is answered in `rejected` by its index and the rest still land.
+     * Rows are applied in order, so a later row may build on an earlier one, and a loop split
+     * across two rows is refused on the second.
+     *
+     * Not atomic and not deduplicated by an idempotency key, but safe to repeat: sending the same
+     * rows again updates them to what they already are.
+     *
+     * **Coded refusals:**
+     * - `REDIRECT_IMPORT_INVALID` → `ValidationError` (400), before any request: `rows` is not an
+     *   array of 1 to {@link REDIRECT_IMPORT_MAX_ROWS} entries. Send a larger file in chunks.
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` → `BusinessRuleError` (422): the active store is an
+     *   organization's workspace.
+     * - `FORBIDDEN` → `PermissionDeniedError` (403): the credential lacks `UpdateChannel`.
+     *
+     * Waits up to {@link REDIRECT_IMPORT_TIMEOUT_MS}, longer than the client's default deadline. A
+     * timed-out import may still have landed (the service keeps saving): list the redirects, or
+     * send the same rows again, which is safe.
+     *
+     * @effect write
+     * @permission UpdateChannel
+     */
+    import(rows: readonly RedirectImportRow[], options?: Call): Promise<RedirectImportResult>;
+    /**
+     * The store's redirects as two Nginx `map` blocks (text: `$redirect_uri` and
+     * `$redirect_status`, keyed on `$uri`), for a site that is not on the storefront SDK: include
+     * it in the server config and redirect on the mapped values. One entry per source path, those
+     * a storefront cannot serve included.
+     *
+     * @effect read
+     * @permission UpdateChannel
+     */
+    exportNginx(options?: Call): Promise<string>;
 }
 export declare function createRedirectsModule(transport: Transport): RedirectsModule;

package/dist/seo/redirects.js

@@ -1,4 +1,25 @@
-import { createPage, readRestPage } from '@sixtyninecommerce/core';
+import { createPage, readRestPage, ValidationError, } from '@sixtyninecommerce/core';
+/**
+ * The most rows one {@link RedirectsModule.import} takes. Mirrors `ArrayMaxSize` on the plugins
+ * service's `ImportRedirectsDto` (`services/plugins/src/redirects/dto/import-redirects.dto.ts`),
+ * pinned by `__tests__/redirects.spec.ts`. Change both sides together.
+ */
+export const REDIRECT_IMPORT_MAX_ROWS = 5000;
+/**
+ * How long an import may take before the call gives up, unless the caller says otherwise: the
+ * service saves the rows one by one, and a full batch takes far longer than a single write.
+ */
+export const REDIRECT_IMPORT_TIMEOUT_MS = 60_000;
+const IMPORT_INVALID = 'REDIRECT_IMPORT_INVALID';
+/** The import's answer, read defensively: an older service may leave `rejected` out. */
+function importResultOf(body) {
+    const record = (typeof body === 'object' && body !== null ? body : {});
+    const count = (value) => (typeof value === 'number' ? value : 0);
+    const rejected = Array.isArray(record.rejected)
+        ? record.rejected
+        : [];
+    return { created: count(record.created), updated: count(record.updated), rejected };
+}
 export function createRedirectsModule(transport) {
     async function list(options) {
         // `GET /redirects` answers with a bare array unless the request OPTS IN.
@@ -33,5 +54,43 @@ export function createRedirectsModule(transport) {
             // discards the body rather than pretending it is a Redirect.
             await transport.rest('plugins', { method: 'DELETE', path: `/redirects/${encodeURIComponent(id)}`, expect: 'void' }, options);
         },
+        async import(rows, options) {
+            if (!Array.isArray(rows) || rows.length === 0 || rows.length > REDIRECT_IMPORT_MAX_ROWS) {
+                throw new ValidationError({
+                    code: IMPORT_INVALID,
+                    message: `Send 1 to ${String(REDIRECT_IMPORT_MAX_ROWS)} redirects per import; split a larger file into several calls.`,
+                    status: 400,
+                    service: 'plugins',
+                    details: [
+                        {
+                            field: 'rows',
+                            code: IMPORT_INVALID,
+                            message: Array.isArray(rows)
+                                ? `${String(rows.length)} rows sent.`
+                                : 'rows is not an array.',
+                        },
+                    ],
+                });
+            }
+            const body = await transport.rest('plugins', {
+                method: 'POST',
+                path: '/redirects/import',
+                // Only the three row fields go out: the service's DTO refuses any other key, which
+                // would fail the whole batch rather than the one row.
+                body: {
+                    redirects: rows.map((row) => ({
+                        oldPath: row.oldPath,
+                        newPath: row.newPath,
+                        ...(row.statusCode === undefined ? {} : { statusCode: row.statusCode }),
+                    })),
+                },
+            }, { timeoutMs: REDIRECT_IMPORT_TIMEOUT_MS, ...options });
+            return importResultOf(body);
+        },
+        async exportNginx(options) {
+            // A text body, never JSON: `blob` keeps the transport from parsing or case-converting it.
+            const answer = await transport.rest('plugins', { method: 'GET', path: '/redirects/nginx', expect: 'blob' }, options);
+            return answer.blob.text();
+        },
     };
 }

package/dist/seo/settings.d.ts

@@ -0,0 +1,147 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { SettingsSourceKind } from '../tenant/settings-sources.js';
+import type { Call } from '../types.js';
+/**
+ * How a language shows in storefront URLs. Mirrors the meta catalog's `URL_LOCALE_STRATEGIES`
+ * (`packages/shared/src/meta-catalog/plugin-config-schemas.ts`), which the engine enforces,
+ * pinned by `__tests__/seo-settings.spec.ts`.
+ */
+export declare const URL_LOCALE_STRATEGIES: readonly ["path-prefix", "subdomain", "none"];
+export type UrlLocaleStrategy = (typeof URL_LOCALE_STRATEGIES)[number];
+/** What an AI crawler may do with the store's pages. */
+export type AiBotDirective = 'allow' | 'deny';
+/**
+ * The store's SEO defaults: the `settings.seo` group's channel half, which a member store may take
+ * from its organization.
+ */
+export interface SeoDefaults {
+    /** Without the `@`; storefronts emit it as `twitter:site`. Null for none. */
+    twitterHandle: string | null;
+    /** The asset shared as the OpenGraph image when a product has none; null for none. */
+    defaultOgImageId: string | null;
+    /** AI crawler → `allow` or `deny`. A crawler left out follows the storefront's own default. */
+    aiBotDefaults: Record<string, AiBotDirective>;
+    /** The storefront advertises its AI-friendly endpoints at `/llms.txt`. */
+    llmsTxtEnabled: boolean;
+    /** Plain text merged into the store's `robots.txt`; null for none. */
+    robotsTxtCustom: string | null;
+}
+/** Where the SEO defaults storefronts get come from (`settings.seo`). */
+export interface SeoDefaultsSource {
+    /** `channel`: the store's own defaults apply; `organization`: its organization's. */
+    source: SettingsSourceKind | (string & {});
+    /**
+     * The organization locks the group: {@link SeoSettingsModule.set} refuses a changed default with
+     * `MANAGED_BY_ORGANIZATION`, SuperAdmins included.
+     */
+    locked: boolean;
+    /** The organization shares the group without locking it, so the store may override it. */
+    inheritable: boolean;
+    /** The store keeps its own defaults although the organization shares the group. */
+    overridden: boolean;
+    /** The store's organization; null for a store outside any organization. */
+    organizationName: string | null;
+    /** The defaults storefronts get: the store's own while `source` is `channel`, else the organization's. */
+    effective: SeoDefaults;
+}
+/**
+ * The ACTIVE store's SEO settings as its channel stores them. The top-level defaults are the
+ * store's OWN values, which {@link SeoSettingsModule.set} writes; while the store takes
+ * `settings.seo` from its organization, storefronts get `defaultsSource.effective` instead.
+ */
+export interface SeoSettings extends SeoDefaults {
+    /** The store these are the settings of (its channel id). */
+    channelId: string;
+    defaultLanguageCode: string;
+    /** The store's languages, its default included. */
+    availableLanguageCodes: string[];
+    /**
+     * The storefront's address, the base of canonical, hreflang and sitemap URLs; null when none.
+     * Always the store's own. While the store has a default web head, the head's address is copied
+     * over it on every head change.
+     */
+    storefrontUrl: string | null;
+    /**
+     * How a language shows in storefront URLs; `path-prefix` when the store never chose. A string
+     * the engine accepts that this SDK does not name yet passes through. Always the store's own.
+     */
+    urlLocaleStrategy: UrlLocaleStrategy | (string & {});
+    /** The default language carries a prefix too. Always the store's own. */
+    urlLocalePrefixDefault: boolean;
+    defaultsSource: SeoDefaultsSource;
+}
+/**
+ * A patch of {@link SeoSettings}: a key left out is unchanged, `null` clears it. At least one key.
+ * The read-only keys `get` answers (`channelId`, the languages, `defaultsSource`) are ignored, so
+ * `set({ ...settings, urlLocaleStrategy: 'subdomain' })` works.
+ */
+export interface SeoSettingsPatch {
+    /** At most 255 characters; not checked to be a URL. */
+    storefrontUrl?: string | null;
+    /**
+     * One of {@link URL_LOCALE_STRATEGIES}, or null for the default (`path-prefix`). Typed as any
+     * string so a strategy `get` answered (one this SDK may not name yet) can be sent back; the
+     * engine refuses one it does not know (`USER_INPUT_ERROR`).
+     */
+    urlLocaleStrategy?: UrlLocaleStrategy | (string & {}) | null;
+    urlLocalePrefixDefault?: boolean | null;
+    /** At most 50 characters, without the `@`. */
+    twitterHandle?: string | null;
+    defaultOgImageId?: string | null;
+    /** The whole map (it replaces the stored one), as an object: the SDK encodes it. */
+    aiBotDefaults?: Record<string, AiBotDirective> | null;
+    llmsTxtEnabled?: boolean | null;
+    robotsTxtCustom?: string | null;
+}
+/**
+ * `admin.seo.settings`: the ACTIVE store's SEO channel settings (Settings → SEO): the storefront
+ * URL and how languages show in its URLs, and the SEO defaults (share card, AI crawlers,
+ * `llms.txt`, `robots.txt`). Stored as Channel custom fields; written through core `updateChannel`
+ * (typed per domain, ruling G80).
+ *
+ * The other half of the page, the SEO automation (automatic redirects, IndexNow, the audit
+ * schedule), lives on the plugins service: `admin.seo.config`.
+ */
+export interface SeoSettingsModule {
+    /**
+     * The settings, and where the defaults storefronts get come from. Reading needs an
+     * administrator of the store with any permission beyond `Authenticated`.
+     *
+     * @effect read
+     */
+    get(options?: Call): Promise<SeoSettings>;
+    /**
+     * Change the settings `patch` names, and answer them all as the engine now stores them. The
+     * storefront picks the change up on its next read of the store's settings.
+     *
+     * **Coded refusals:**
+     * - `SEO_SETTINGS_INVALID` → `ValidationError` (400), before any request: an empty patch, a
+     *   key that is not an SEO setting, or an `aiBotDefaults` that is not an object (or null). One
+     *   `details[]` entry per key, `field` naming it.
+     * - `CHANNEL_SETTINGS_INVALID` → `ValidationError` (400), from the engine: an `aiBotDefaults`
+     *   the platform's schema refuses (a directive other than `allow` or `deny`).
+     *   `details[].field` is `customFields.aiBotDefaults`.
+     * - `USER_INPUT_ERROR` → `ValidationError` (400): a `urlLocaleStrategy` outside
+     *   {@link URL_LOCALE_STRATEGIES}.
+     * - `MANAGED_BY_ORGANIZATION` → `BusinessRuleError` (422): a changed default while the
+     *   organization locks `settings.seo`.
+     * - `ORGANIZATION_SETTINGS_INHERITED` → `BusinessRuleError` (422): a changed default while the
+     *   store inherits the group; `tenant.settingsSources.override('settings.seo')` it first.
+     *   Sending the stored value back unchanged is accepted and changes nothing.
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` → `BusinessRuleError` (422): a storefront URL for an
+     *   organization's workspace, which has no storefront.
+     * - `FORBIDDEN` → `PermissionDeniedError` (403): the credential lacks `UpdateChannel`.
+     *
+     * @effect write
+     * @permission UpdateChannel
+     */
+    set(patch: SeoSettingsPatch, options?: Call): Promise<SeoSettings>;
+}
+export declare const SEO_SETTINGS_QUERY = "\n  query SeoSettings {\n    activeChannel { \n  id\n  defaultLanguageCode\n  availableLanguageCodes\n  customFields {\n    storefrontUrl\n    urlLocaleStrategy\n    urlLocalePrefixDefault\n    twitterHandle\n    defaultOgImageId\n    aiBotDefaults\n    llmsTxtEnabled\n    robotsTxtCustom\n  }\n }\n    channelSettingsSources { group source locked overridden inheritable organizationName values }\n  }\n";
+export declare const UPDATE_SEO_SETTINGS_MUTATION = "\n  mutation UpdateSeoSettings($input: UpdateChannelInput!) {\n    updateChannel(input: $input) {\n      ... on Channel { \n  id\n  defaultLanguageCode\n  availableLanguageCodes\n  customFields {\n    storefrontUrl\n    urlLocaleStrategy\n    urlLocalePrefixDefault\n    twitterHandle\n    defaultOgImageId\n    aiBotDefaults\n    llmsTxtEnabled\n    robotsTxtCustom\n  }\n }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
+/**
+ * `aiBotDefaults` as the column stores it (JSON text) or already decoded (an organization's
+ * `values`); a directive other than `allow` or `deny` is left out, an unreadable value is none.
+ */
+export declare function readAiBotDefaults(raw: unknown): Record<string, AiBotDirective>;
+export declare function createSeoSettingsModule(transport: Transport): SeoSettingsModule;

package/dist/seo/settings.js

@@ -0,0 +1,209 @@
+import { errorFromErrorResult, isErrorResult, NotFoundError, ValidationError, } from '@sixtyninecommerce/core';
+/**
+ * How a language shows in storefront URLs. Mirrors the meta catalog's `URL_LOCALE_STRATEGIES`
+ * (`packages/shared/src/meta-catalog/plugin-config-schemas.ts`), which the engine enforces,
+ * pinned by `__tests__/seo-settings.spec.ts`.
+ */
+export const URL_LOCALE_STRATEGIES = ['path-prefix', 'subdomain', 'none'];
+/** The settings group the defaults belong to (multi-region spec §5.3). */
+const SEO_GROUP = 'settings.seo';
+const CHANNEL_FIELDS = /* GraphQL */ `
+  id
+  defaultLanguageCode
+  availableLanguageCodes
+  customFields {
+    storefrontUrl
+    urlLocaleStrategy
+    urlLocalePrefixDefault
+    twitterHandle
+    defaultOgImageId
+    aiBotDefaults
+    llmsTxtEnabled
+    robotsTxtCustom
+  }
+`;
+export const SEO_SETTINGS_QUERY = /* GraphQL */ `
+  query SeoSettings {
+    activeChannel { ${CHANNEL_FIELDS} }
+    channelSettingsSources { group source locked overridden inheritable organizationName values }
+  }
+`;
+export const UPDATE_SEO_SETTINGS_MUTATION = /* GraphQL */ `
+  mutation UpdateSeoSettings($input: UpdateChannelInput!) {
+    updateChannel(input: $input) {
+      ... on Channel { ${CHANNEL_FIELDS} }
+      ... on ErrorResult { errorCode message }
+    }
+  }
+`;
+const INVALID = 'SEO_SETTINGS_INVALID';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const stringOrNull = (value) => (typeof value === 'string' ? value : null);
+/**
+ * `aiBotDefaults` as the column stores it (JSON text) or already decoded (an organization's
+ * `values`); a directive other than `allow` or `deny` is left out, an unreadable value is none.
+ */
+export function readAiBotDefaults(raw) {
+    let parsed = raw;
+    if (typeof raw === 'string') {
+        if (raw === '')
+            return {};
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    }
+    if (!isRecord(parsed))
+        return {};
+    const out = {};
+    for (const [bot, directive] of Object.entries(parsed)) {
+        if (directive === 'allow' || directive === 'deny')
+            out[bot] = directive;
+    }
+    return out;
+}
+function defaultsOf(fields) {
+    return {
+        twitterHandle: stringOrNull(fields.twitterHandle),
+        defaultOgImageId: stringOrNull(fields.defaultOgImageId),
+        aiBotDefaults: readAiBotDefaults(fields.aiBotDefaults),
+        llmsTxtEnabled: fields.llmsTxtEnabled === true,
+        robotsTxtCustom: stringOrNull(fields.robotsTxtCustom),
+    };
+}
+function sourceOf(sources, own) {
+    const group = sources.find((item) => item.group === SEO_GROUP);
+    if (!group) {
+        return {
+            source: 'channel',
+            locked: false,
+            inheritable: false,
+            overridden: false,
+            organizationName: null,
+            effective: own,
+        };
+    }
+    // The store's own defaults when its own apply: after `set` the sources are the ones read BEFORE
+    // the write, so their values would answer the old defaults. The organization's otherwise.
+    return {
+        source: group.source,
+        locked: group.locked,
+        inheritable: group.inheritable,
+        overridden: group.overridden,
+        organizationName: group.organizationName ?? null,
+        effective: group.source !== 'channel' && group.values ? defaultsOf(group.values) : own,
+    };
+}
+function settingsOf(channel, sources) {
+    const fields = channel.customFields ?? {};
+    const own = defaultsOf(fields);
+    return {
+        channelId: channel.id,
+        defaultLanguageCode: channel.defaultLanguageCode,
+        availableLanguageCodes: channel.availableLanguageCodes ?? [channel.defaultLanguageCode],
+        storefrontUrl: stringOrNull(fields.storefrontUrl),
+        urlLocaleStrategy: stringOrNull(fields.urlLocaleStrategy) ?? 'path-prefix',
+        urlLocalePrefixDefault: fields.urlLocalePrefixDefault === true,
+        ...own,
+        defaultsSource: sourceOf(sources, own),
+    };
+}
+const PATCH_KEYS = [
+    'storefrontUrl',
+    'urlLocaleStrategy',
+    'urlLocalePrefixDefault',
+    'twitterHandle',
+    'defaultOgImageId',
+    'aiBotDefaults',
+    'llmsTxtEnabled',
+    'robotsTxtCustom',
+];
+const KNOWN_KEYS = new Set(PATCH_KEYS);
+/** What `get` answers beside the settings: sent back in a spread, never written. */
+const READ_ONLY_KEYS = new Set([
+    'channelId',
+    'defaultLanguageCode',
+    'availableLanguageCodes',
+    'defaultsSource',
+]);
+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. { urlLocaleStrategy: 'none' }.");
+        return problems;
+    }
+    const named = Object.keys(patch).filter((key) => patch[key] !== undefined && !READ_ONLY_KEYS.has(key));
+    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)) {
+            add(key, `${key} is not an SEO setting; the settings are ${PATCH_KEYS.join(', ')}.`);
+        }
+    }
+    const bots = patch.aiBotDefaults;
+    if (bots !== undefined && bots !== null && !isRecord(bots)) {
+        // A string would be encoded a second time and stored as a JSON string, not a map.
+        add('aiBotDefaults', "aiBotDefaults must be an object of crawler → 'allow' | 'deny' (the SDK encodes it), or null to clear it.");
+    }
+    return problems;
+}
+/** The custom fields `patch` writes: only the keys it names, the bot map as the column's JSON. */
+function customFieldsOf(patch) {
+    const fields = {};
+    for (const key of PATCH_KEYS) {
+        const value = patch[key];
+        if (value === undefined)
+            continue;
+        fields[key] = key === 'aiBotDefaults' && value !== null ? JSON.stringify(value) : value;
+    }
+    return fields;
+}
+export function createSeoSettingsModule(transport) {
+    const read = async (options) => {
+        const data = await transport.graphql({ api: 'admin', query: SEO_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 SEO 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, 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_SEO_SETTINGS_MUTATION,
+                variables: { input: { id: channel.id, customFields: customFieldsOf(patch) } },
+            }, options);
+            if (isErrorResult(data.updateChannel))
+                throw errorFromErrorResult(data.updateChannel);
+            // An SEO settings write never changes where the defaults come from, so the sources read
+            // just before still hold; `sourceOf` takes the new own defaults when the store's apply.
+            return settingsOf(data.updateChannel, sources);
+        },
+    };
+}

package/dist/shipping/index.d.ts

@@ -12,6 +12,7 @@ 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';
+import { type ShipToCountriesModule } from './ship-to-countries.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. */
@@ -44,5 +45,10 @@ export interface ShippingModule {
      * default profile, and who is emailed per handler when a fulfilment is created.
      */
     fulfillmentProfiles: FulfillmentProfilesModule;
+    /**
+     * The countries the store ships to, as checkout applies them: which ones its storefront offers,
+     * which selected ones no shopper can choose, saved or previewed.
+     */
+    shipToCountries: ShipToCountriesModule;
 }
 export declare function createShippingModule(transport: Transport): ShippingModule;

package/dist/shipping/index.js

@@ -11,6 +11,7 @@ import { createMyparcelModule } from './myparcel.js';
 import { createParcelCountSuggestion, } from './parcel-count-suggestion.js';
 import { createParcelRuleModule } from './parcel-rule.js';
 import { createRateTablesModule } from './rate-tables.js';
+import { createShipToCountriesModule } from './ship-to-countries.js';
 export function createShippingModule(transport) {
     return {
         methods: createShippingMethodsModule(transport),
@@ -21,5 +22,6 @@ export function createShippingModule(transport) {
         hendriks: createHendriksModule(transport),
         myparcel: createMyparcelModule(transport),
         fulfillmentProfiles: createFulfillmentProfilesModule(transport),
+        shipToCountries: createShipToCountriesModule(transport),
     };
 }

package/dist/shipping/methods.d.ts

@@ -154,6 +154,11 @@ export interface ShippingMethodsModule {
      * - 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.
+     * - `SHIPPING_ZONE_CONFIG_NOT_FOUND` (`NotFoundError`, 404): the `weight-zone-shipping-calculator`
+     *   names no rate table of the store (`admin.shipping.rateTables`): its `shippingZoneConfigId` is
+     *   empty or left out (detail code `required`), or is not one of the store's table ids (`enum`;
+     *   another store's, a deleted one and a malformed one read alike). Such a method would quote no
+     *   price. `details[0].field` points at the argument (`/input/calculator/arguments/<i>/value`).
      *
      * @effect write
      */
@@ -165,7 +170,9 @@ export interface ShippingMethodsModule {
      *
      * 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:
+     * or calculator the patch CHANGES: one the method already has is no new pick;
+     * `SHIPPING_ZONE_CONFIG_NOT_FOUND` whenever the patch sends a weight-zone calculator, judged in
+     * the store the client is on, and never when it sends none), and:
      *
      * - `ENTITY_NOT_FOUND` (`NotFoundError`, 404): the store has no such method (another store's
      *   reads the same).