@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/payments/index.js

@@ -1,3 +1,5 @@
+import { createAccountCreditModule } from './account-credit.js';
+import { createPaymentMethodsModule } from './methods.js';
 import { createProvidersModule } from './providers.js';
 const PAID_ORDER_FIELDS = /* GraphQL */ `
   id
@@ -64,9 +66,66 @@ export const REFUND_ORDER_PAYMENT_MUTATION = /* GraphQL */ `
     }
   }
 `;
+export const UNRECONCILED_REFUNDS_QUERY = /* GraphQL */ `
+  query UnreconciledRefunds($orderId: ID!) {
+    orderRefundPosition(orderId: $orderId) {
+      unreconciled {
+        refundId
+        paymentId
+        amount
+        createdAt
+      }
+    }
+  }
+`;
+export const RECONCILE_REFUND_OUTCOME_MUTATION = /* GraphQL */ `
+  mutation ReconcileRefundOutcome($input: ReconcileRefundOutcomeInput!, $idempotencyKey: String) {
+    reconcileRefundOutcome(input: $input, idempotencyKey: $idempotencyKey) {
+      id
+      total
+      state
+      method
+      transactionId
+      reason
+    }
+  }
+`;
+export const REPORT_APP_PAYMENT_MUTATION = /* GraphQL */ `
+  mutation ReportAppPayment(
+    $paymentId: ID!
+    $input: ReportAppPaymentInput!
+    $idempotencyKey: String!
+  ) {
+    reportAppPayment(paymentId: $paymentId, input: $input, idempotencyKey: $idempotencyKey) {
+      id
+      state
+      amount
+      method
+      transactionId
+    }
+  }
+`;
+export const APP_PAYMENTS_QUERY = /* GraphQL */ `
+  query AppPayments($orderId: ID!) {
+    appPayments(orderId: $orderId) {
+      id
+      orderId
+      orderCode
+      state
+      amount
+      currencyCode
+      providerReference
+      methodCode
+      outcomeUnknown
+      createdAt
+    }
+  }
+`;
 export function createPaymentsModule(transport) {
     return {
         providers: createProvidersModule(transport),
+        accountCredit: createAccountCreditModule(transport),
+        methods: createPaymentMethodsModule(transport),
         async record(orderId, input, options) {
             const data = await transport.graphql({
                 api: 'admin',
@@ -99,5 +158,38 @@ export function createPaymentsModule(transport) {
             const data = await transport.graphql({ api: 'admin', query: ORDER_REFUND_POSITION_QUERY, variables: { orderId } }, options);
             return data.orderRefundPosition;
         },
+        // Its own query rather than a field on `refundPosition`'s: an SDK released
+        // ahead of a server without `unreconciled` must not break that read.
+        async unreconciledRefunds(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: UNRECONCILED_REFUNDS_QUERY, variables: { orderId } }, options);
+            return data.orderRefundPosition.unreconciled;
+        },
+        async reconcileRefund(input, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: RECONCILE_REFUND_OUTCOME_MUTATION,
+                // A variable, not a header: the Admin API takes the key as an argument.
+                variables: { input, idempotencyKey: options?.idempotencyKey },
+            }, options);
+            return data.reconcileRefundOutcome;
+        },
+        async reportAppPayment(paymentId, input, options) {
+            // Refused here rather than sent: the argument is non-null on the wire, and
+            // a report without a key could never be safely repeated.
+            if (typeof options?.idempotencyKey !== 'string' || options.idempotencyKey.trim() === '') {
+                throw new TypeError('reportAppPayment needs options.idempotencyKey: one key per provider event.');
+            }
+            const data = await transport.graphql({
+                api: 'admin',
+                query: REPORT_APP_PAYMENT_MUTATION,
+                // A variable, not a header: the Admin API takes the key as an argument.
+                variables: { paymentId, input, idempotencyKey: options.idempotencyKey },
+            }, options);
+            return data.reportAppPayment;
+        },
+        async appPayments(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: APP_PAYMENTS_QUERY, variables: { orderId } }, options);
+            return data.appPayments;
+        },
     };
 }

package/dist/payments/methods.d.ts

@@ -0,0 +1,37 @@
+import type { Page, Transport } from '@sixtyninecommerce/core';
+import type { ListOptions } from '../types.js';
+/** One payment method of the store, as staff choose one. */
+export interface PaymentMethod {
+    id: string;
+    /**
+     * The method's code: what `payments.record` takes as `method`, and what a
+     * deposit policy names in `storefront.methods`.
+     */
+    code: string;
+    name: string;
+    /** A disabled method takes no new payments; it still names the ones it took. */
+    enabled: boolean;
+    /**
+     * The code of the handler that takes the money (`manual-payment`, `mollie`, a
+     * payment app's handler, …): what kind of method this is.
+     */
+    handlerCode: string;
+}
+/**
+ * The store's payment methods (`admin.payments.methods`): what staff record a
+ * payment with, and what a deposit policy names.
+ *
+ * Needs `ReadSettings` or `ReadPaymentMethod`. Scoped to the channel the client
+ * is on: another store's methods are not listed.
+ */
+export interface PaymentMethodsModule {
+    /**
+     * Every method of the store, enabled or not, in the engine's 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.
+     */
+    list(options?: ListOptions): Promise<Page<PaymentMethod>>;
+}
+export declare const PAYMENT_METHODS_QUERY = "\n  query StorePaymentMethods($options: PaymentMethodListOptions) {\n    paymentMethods(options: $options) {\n      items {\n        id\n        code\n        name\n        enabled\n        handler {\n          code\n        }\n      }\n      totalItems\n    }\n  }\n";
+export declare function createPaymentMethodsModule(transport: Transport): PaymentMethodsModule;

package/dist/payments/methods.js

@@ -0,0 +1,33 @@
+import { vendureListPage } from '../catalog/types.js';
+/** A store has a handful; one page holds them. */
+const DEFAULT_PAGE_SIZE = 100;
+export const PAYMENT_METHODS_QUERY = /* GraphQL */ `
+  query StorePaymentMethods($options: PaymentMethodListOptions) {
+    paymentMethods(options: $options) {
+      items {
+        id
+        code
+        name
+        enabled
+        handler {
+          code
+        }
+      }
+      totalItems
+    }
+  }
+`;
+const toMethod = (method) => ({
+    id: method.id,
+    code: method.code,
+    name: method.name,
+    enabled: method.enabled,
+    handlerCode: method.handler.code,
+});
+export function createPaymentMethodsModule(transport) {
+    return {
+        list(options) {
+            return vendureListPage(transport, PAYMENT_METHODS_QUERY, 'paymentMethods', (skip, take) => ({ options: { skip, take } }), { ...options, limit: options?.limit ?? DEFAULT_PAGE_SIZE }, toMethod);
+        },
+    };
+}

package/dist/platform/catalog.d.ts

@@ -0,0 +1,148 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { AdminClientConfig } from '../client.js';
+import type { Call } from '../types.js';
+/** Which kind of catalogue entity a repair row is about. */
+export type TranslationRepairEntityKind = 'PRODUCT' | 'VARIANT';
+/**
+ * Why the repair left a candidate alone. A string on the wire, not an enum, so
+ * a reason added later never breaks a caller:
+ *
+ * - `SHARED_CHANNEL_LANGUAGES_DIFFER`: another store holds the entity and offers
+ *   other languages, so a row foreign here may be that store's own.
+ * - `CARRIER_PRODUCT`: the platform's hidden external-line carrier.
+ * - `DEFAULT_ROW_GONE`: its default-language row disappeared before it could be
+ *   repaired.
+ */
+export type TranslationRepairSkipReason = 'SHARED_CHANNEL_LANGUAGES_DIFFER' | 'CARRIER_PRODUCT' | 'DEFAULT_ROW_GONE' | (string & {});
+export interface RepairTranslationLanguagesInput {
+    /** The store to repair. The root channel and organization hubs are refused. */
+    channelId: string;
+    /**
+     * `true` reports what would be removed and changes nothing; `false` removes
+     * it. Both take the same path on the server, so a dry run is an exact preview
+     * of the apply that follows it (as long as the catalogue does not change in
+     * between).
+     */
+    dryRun: boolean;
+    /**
+     * Products and variants examined per page. The server defaults to 100 and
+     * treats anything above 500 as 500; below 1 is refused
+     * (`TRANSLATION_REPAIR_LIMIT_INVALID`).
+     */
+    limit?: number;
+    /**
+     * The `nextCursor` of the previous page of the SAME run: same store, same
+     * `dryRun`. Omitted or null starts from the beginning. A cursor issued for
+     * another store or the other mode is refused (`TRANSLATION_REPAIR_CURSOR_INVALID`),
+     * so a dry run's cursor can never make an apply skip the pages before it.
+     */
+    cursor?: string | null;
+    /**
+     * On the first page (no cursor) only: also list the store's single-variant
+     * products whose variant name differs from the product name.
+     */
+    includeNameReport?: boolean;
+}
+/**
+ * A translation row the repair removes, or in a dry run would remove. The whole
+ * row, so a dry run's answer is the undo record of the apply.
+ */
+export interface TranslationRepairRemovedRow {
+    translationId: string;
+    languageCode: string;
+    name: string;
+    /** Products only; null for a variant. */
+    slug: string | null;
+    /** Products only; null for a variant. */
+    description: string | null;
+}
+/**
+ * A product or variant with a row in the store's default language and one or
+ * more rows in languages the store does not offer.
+ */
+export interface TranslationRepairEntity {
+    kind: TranslationRepairEntityKind;
+    id: string;
+    /** The product itself for a `PRODUCT`, the variant's product for a `VARIANT`. */
+    productId: string;
+    /** Variants only; null for a product. */
+    sku: string | null;
+    /** The language of the row the merchant sees, which stays. */
+    keptLanguageCode: string;
+    /** The name the merchant sees, which stays. */
+    keptName: string;
+    removed: TranslationRepairRemovedRow[];
+}
+/** A candidate the repair leaves alone, and why. */
+export interface TranslationRepairSkipped {
+    kind: TranslationRepairEntityKind;
+    id: string;
+    productId: string;
+    sku: string | null;
+    /** The name the merchant sees. */
+    name: string;
+    reason: TranslationRepairSkipReason;
+}
+/**
+ * A single-variant product whose variant shows another name than the product.
+ * Report only: the repair never renames.
+ */
+export interface TranslationRepairNameMismatch {
+    productId: string;
+    variantId: string;
+    sku: string;
+    productName: string;
+    variantName: string;
+}
+/** One page of a repair run, exactly as the engine answers it. */
+export interface TranslationRepairPage {
+    /** Fresh for every call; the audit rows of an apply page carry it. */
+    runId: string;
+    dryRun: boolean;
+    channelId: string;
+    channelCode: string;
+    defaultLanguageCode: string;
+    /** The default language first, then the store's other available languages. */
+    offeredLanguageCodes: string[];
+    repaired: TranslationRepairEntity[];
+    skipped: TranslationRepairSkipped[];
+    /**
+     * Products and variants whose rows are ALL in languages the store does not
+     * offer. Never touched (removing them would remove their only name). Counted
+     * on the first page only; 0 on later pages.
+     */
+    foreignOnlyCount: number;
+    /** First page with `includeNameReport` only, for the whole store; empty otherwise. */
+    nameMismatches: TranslationRepairNameMismatch[];
+    /** Pass back as `cursor` to continue this run; null when every candidate was examined. */
+    nextCursor: string | null;
+}
+/**
+ * `admin.platform.catalog` — SuperAdmin catalogue maintenance across stores.
+ * An API token or an app credential is refused BEFORE anything is sent
+ * (`PLATFORM_REQUIRES_SESSION`); the server refuses one anyway.
+ */
+export interface PlatformCatalogModule {
+    /**
+     * One page of the translation-language repair for one store: removes the
+     * store's product and variant translation rows in languages it does not
+     * offer, ONLY from entities that also have a row in the store's default
+     * language. It never writes a name and never touches an entity whose rows
+     * are all foreign (`foreignOnlyCount`).
+     *
+     * Run it with `dryRun: true` first and keep the answer: its removed rows are
+     * the undo record. Follow `nextCursor` until it is null to cover the store;
+     * each page is its own transaction, so an apply that stops half-way leaves
+     * the pages before it applied and is safe to run again from the start.
+     *
+     * Refusals: `TRANSLATION_REPAIR_CHANNEL_NOT_FOUND` (404 `NotFoundError`),
+     * `TRANSLATION_REPAIR_NOT_A_STORE` (422 `BusinessRuleError`: the root channel
+     * or an organization hub), `TRANSLATION_REPAIR_CURSOR_INVALID` and
+     * `TRANSLATION_REPAIR_LIMIT_INVALID` (400 `ValidationError`), and
+     * `CHANNEL_ACCESS_DENIED` / `FORBIDDEN` (403 `PermissionDeniedError`) for a
+     * caller who is not a SuperAdmin.
+     */
+    repairTranslationLanguages(input: RepairTranslationLanguagesInput, call?: Call): Promise<TranslationRepairPage>;
+}
+export declare const REPAIR_TRANSLATION_LANGUAGES_MUTATION = "\n  mutation PlatformRepairProductTranslationLanguages($input: ProductTranslationRepairInput!) {\n    repairProductTranslationLanguages(input: $input) {\n      runId\n      dryRun\n      channelId\n      channelCode\n      defaultLanguageCode\n      offeredLanguageCodes\n      repaired {\n        kind\n        id\n        productId\n        sku\n        keptLanguageCode\n        keptName\n        removed {\n          translationId\n          languageCode\n          name\n          slug\n          description\n        }\n      }\n      skipped {\n        kind\n        id\n        productId\n        sku\n        name\n        reason\n      }\n      foreignOnlyCount\n      nameMismatches {\n        productId\n        variantId\n        sku\n        productName\n        variantName\n      }\n      nextCursor\n    }\n  }\n";
+export declare function createPlatformCatalogModule(transport: Transport, config: AdminClientConfig): PlatformCatalogModule;

package/dist/platform/catalog.js

@@ -0,0 +1,74 @@
+import { requireHumanSession } from './guard.js';
+export const REPAIR_TRANSLATION_LANGUAGES_MUTATION = /* GraphQL */ `
+  mutation PlatformRepairProductTranslationLanguages($input: ProductTranslationRepairInput!) {
+    repairProductTranslationLanguages(input: $input) {
+      runId
+      dryRun
+      channelId
+      channelCode
+      defaultLanguageCode
+      offeredLanguageCodes
+      repaired {
+        kind
+        id
+        productId
+        sku
+        keptLanguageCode
+        keptName
+        removed {
+          translationId
+          languageCode
+          name
+          slug
+          description
+        }
+      }
+      skipped {
+        kind
+        id
+        productId
+        sku
+        name
+        reason
+      }
+      foreignOnlyCount
+      nameMismatches {
+        productId
+        variantId
+        sku
+        productName
+        variantName
+      }
+      nextCursor
+    }
+  }
+`;
+export function createPlatformCatalogModule(transport, config) {
+    return {
+        async repairTranslationLanguages(input, call) {
+            requireHumanSession(config);
+            // Only what the caller named: an omitted `limit` must reach the server as
+            // absent, so the SERVER's default applies rather than one copied here.
+            const variables = {
+                channelId: input.channelId,
+                dryRun: input.dryRun,
+            };
+            if (input.limit !== undefined)
+                variables.limit = input.limit;
+            if (input.cursor !== undefined && input.cursor !== null)
+                variables.cursor = input.cursor;
+            if (input.includeNameReport !== undefined) {
+                variables.includeNameReport = input.includeNameReport;
+            }
+            const data = await transport.graphql({
+                api: 'admin',
+                query: REPAIR_TRANSLATION_LANGUAGES_MUTATION,
+                variables: { input: variables },
+            }, 
+            // The store is named in the input, not by the tenant: a SuperAdmin
+            // repairs any store from wherever the client happens to be scoped.
+            { ...call, allowUnscoped: true });
+            return data.repairProductTranslationLanguages;
+        },
+    };
+}

package/dist/platform/entitlements.d.ts

@@ -0,0 +1,111 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { AdminClientConfig } from '../client.js';
+import type { Call } from '../types.js';
+/** Where a store's plugin grant comes from. */
+export type PlatformEntitlementSource = 'channel' | 'organization';
+/**
+ * One plugin grant of a named store (or of an organization's workspace), as the
+ * platform's control plane reads it.
+ */
+export interface PlatformPluginEntitlement {
+    /**
+     * The grant row's id. An `organization` row carries the ORGANIZATION grant's
+     * id, shared by every channel that grant reaches, so pair it with
+     * `channelId` when you need a key that is unique across a `listAll`.
+     */
+    id: string;
+    /** The store, or the organization's workspace channel, the grant applies to. */
+    channelId: string;
+    /** The plugin's catalog key (`pos`, `afas`, `mollie`, …), exactly as the engine sends it. */
+    pluginKey: string;
+    /** ISO-8601 UTC. Connecting a plugin that is already connected refreshes it. */
+    connectedAt: string;
+    connectedByUserId: string | null;
+    notes: string | null;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * `channel` for the store's own grant, `organization` for one its
+     * organization holds for every member store and its workspace. When both
+     * exist the store's own row wins, so a store lists a key once. An
+     * `organization` grant is changed on the organization
+     * (`platform.organizations.entitlements.set`), never through
+     * {@link PlatformEntitlementsModule.set}. A string on the wire: a newer
+     * engine may answer a source this SDK does not name yet.
+     */
+    source: PlatformEntitlementSource | (string & {});
+}
+export interface SetPlatformEntitlementOptions {
+    /** `true` connects the plugin for the store; `false` removes the store's own grant. */
+    connected: boolean;
+    /**
+     * Operator notes, kept with the store's own grant. Omitted keeps the notes
+     * already stored; `''` clears them. Ignored on a disconnect, which deletes
+     * the row. At most 512 characters: the engine stores no more, and a longer
+     * value fails the write.
+     */
+    notes?: string;
+}
+/**
+ * `admin.platform.entitlements` — which external plugins each store may use,
+ * read and switched by the platform's operators (spec §7, §9.2 `platform`).
+ *
+ * SuperAdmin with a HUMAN session only: an API token or an app credential is
+ * refused with `PLATFORM_REQUIRES_SESSION` (403) before anything is sent, and a
+ * session without SuperAdmin is refused `FORBIDDEN` (403) by the engine. The
+ * calls are platform-wide, so the client needs no tenant.
+ *
+ * Core plugins (search, email) are on for every store and never have a row.
+ * The engine reads these rows on every operation; the plugins service's own
+ * gates follow a change within its 60-second entitlement cache.
+ */
+export interface PlatformEntitlementsModule {
+    /**
+     * The plugins one store may use: its own grants and the ones its
+     * organization holds (`source`), by plugin key. The store's own row wins
+     * where both exist. An organization's workspace channel lists its
+     * organization's grants the same way. The engine does not check that the
+     * channel exists: an unknown id is not refused, it answers the rows stored
+     * under it (normally none).
+     */
+    list(channelId: string, call?: Call): Promise<PlatformPluginEntitlement[]>;
+    /**
+     * Every grant across the platform. An organization grant appears once per
+     * member store and once for the organization's workspace
+     * (`source: 'organization'`, each under that channel's id), except where the
+     * channel holds the plugin itself.
+     */
+    listAll(call?: Call): Promise<PlatformPluginEntitlement[]>;
+    /**
+     * Connect (`connected: true`) or disconnect (`connected: false`) an external
+     * plugin for one store.
+     *
+     * - Connecting answers the store's own row; connecting again refreshes
+     *   `connectedAt` and `connectedByUserId` (and the notes, when given).
+     * - Disconnecting deletes the store's OWN row and answers `null`. A plugin
+     *   the store's organization also grants stays connected through it: read
+     *   {@link list} again to see it as `source: 'organization'`.
+     *
+     * Refusals: `MANAGED_BY_ORGANIZATION` (422 `BusinessRuleError`: the store
+     * holds the plugin only through its organization; revoke it there),
+     * `ORGANIZATION_WORKSPACE_NOT_A_STORE` (422: an organization's workspace
+     * cannot be connected on its own; grant the plugin to the organization),
+     * `USER_INPUT_ERROR` (400 `ValidationError`: a key that is not an external
+     * plugin of the catalog), `FORBIDDEN` (403). The engine does not check
+     * that `channelId` names a store, so pass an id read from the platform's
+     * channel list.
+     *
+     * Not deduplicated by an idempotency key (an Admin API mutation). A second
+     * connect refreshes the same row. A second disconnect answers `null` again,
+     * unless the organization also grants the plugin: the first removed the
+     * store's own grant, so the second is refused `MANAGED_BY_ORGANIZATION`.
+     * After a disconnect whose answer was lost, read {@link list} instead of
+     * repeating it.
+     */
+    set(channelId: string, pluginKey: string, options: SetPlatformEntitlementOptions, call?: Call): Promise<PlatformPluginEntitlement | null>;
+}
+export declare const TENANT_PLUGIN_ENTITLEMENTS_QUERY = "\n  query PlatformTenantPluginEntitlements($channelId: ID!) {\n    tenantPluginEntitlements(channelId: $channelId) { \n  id\n  channelId\n  pluginKey\n  connectedAt\n  connectedByUserId\n  notes\n  createdAt\n  updatedAt\n  source\n }\n  }\n";
+export declare const ALL_PLUGIN_ENTITLEMENTS_QUERY = "\n  query PlatformAllPluginEntitlements {\n    allPluginEntitlements { \n  id\n  channelId\n  pluginKey\n  connectedAt\n  connectedByUserId\n  notes\n  createdAt\n  updatedAt\n  source\n }\n  }\n";
+export declare const SET_TENANT_PLUGIN_ENTITLEMENT_MUTATION = "\n  mutation PlatformSetTenantPluginEntitlement(\n    $channelId: ID!\n    $pluginKey: String!\n    $connected: Boolean!\n    $notes: String\n  ) {\n    setTenantPluginEntitlement(\n      channelId: $channelId\n      pluginKey: $pluginKey\n      connected: $connected\n      notes: $notes\n    ) { \n  id\n  channelId\n  pluginKey\n  connectedAt\n  connectedByUserId\n  notes\n  createdAt\n  updatedAt\n  source\n }\n  }\n";
+export declare function createPlatformEntitlementsModule(transport: Transport, config: AdminClientConfig): PlatformEntitlementsModule;

package/dist/platform/entitlements.js

@@ -0,0 +1,86 @@
+import { requireHumanSession } from './guard.js';
+const ENTITLEMENT_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  pluginKey
+  connectedAt
+  connectedByUserId
+  notes
+  createdAt
+  updatedAt
+  source
+`;
+export const TENANT_PLUGIN_ENTITLEMENTS_QUERY = /* GraphQL */ `
+  query PlatformTenantPluginEntitlements($channelId: ID!) {
+    tenantPluginEntitlements(channelId: $channelId) { ${ENTITLEMENT_FIELDS} }
+  }
+`;
+export const ALL_PLUGIN_ENTITLEMENTS_QUERY = /* GraphQL */ `
+  query PlatformAllPluginEntitlements {
+    allPluginEntitlements { ${ENTITLEMENT_FIELDS} }
+  }
+`;
+export const SET_TENANT_PLUGIN_ENTITLEMENT_MUTATION = /* GraphQL */ `
+  mutation PlatformSetTenantPluginEntitlement(
+    $channelId: ID!
+    $pluginKey: String!
+    $connected: Boolean!
+    $notes: String
+  ) {
+    setTenantPluginEntitlement(
+      channelId: $channelId
+      pluginKey: $pluginKey
+      connected: $connected
+      notes: $notes
+    ) { ${ENTITLEMENT_FIELDS} }
+  }
+`;
+/** Only the fields this type promises, whatever else a newer engine adds to a row. */
+function toEntitlement(row) {
+    return {
+        id: row.id,
+        channelId: row.channelId,
+        pluginKey: row.pluginKey,
+        connectedAt: row.connectedAt,
+        connectedByUserId: row.connectedByUserId,
+        notes: row.notes,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        source: row.source,
+    };
+}
+export function createPlatformEntitlementsModule(transport, config) {
+    // Platform-wide: a SuperAdmin names the store by id, so no tenant is needed.
+    // Scoped to a store instead, the transport would first resolve that store
+    // through the CMS channel mirror and fail on one missing there.
+    const unscoped = (call) => ({ ...call, allowUnscoped: true });
+    return {
+        async list(channelId, call) {
+            requireHumanSession(config);
+            const data = await transport.graphql({ api: 'admin', query: TENANT_PLUGIN_ENTITLEMENTS_QUERY, variables: { channelId } }, unscoped(call));
+            return data.tenantPluginEntitlements.map(toEntitlement);
+        },
+        async listAll(call) {
+            requireHumanSession(config);
+            const data = await transport.graphql({ api: 'admin', query: ALL_PLUGIN_ENTITLEMENTS_QUERY }, unscoped(call));
+            return data.allPluginEntitlements.map(toEntitlement);
+        },
+        async set(channelId, pluginKey, options, call) {
+            requireHumanSession(config);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_TENANT_PLUGIN_ENTITLEMENT_MUTATION,
+                variables: {
+                    channelId,
+                    pluginKey,
+                    connected: options.connected,
+                    // The engine reads null as "keep the stored notes"; '' is a value
+                    // that clears them, so it must not collapse into null here.
+                    notes: options.notes ?? null,
+                },
+            }, unscoped(call));
+            const row = data.setTenantPluginEntitlement;
+            return row === null ? null : toEntitlement(row);
+        },
+    };
+}