@sixtyninecommerce/admin 0.10.0 → 0.11.0

package/dist/integrations/connections.js

@@ -0,0 +1,55 @@
+import { createPage, NotFoundError, readRestPage, } from '@sixtyninecommerce/core';
+import { PIPELINE_DRAFT_PRESERVE_KEYS, PIPELINE_DRAFT_SLOW_TIMEOUT_MS } from './pipeline-keys.js';
+/**
+ * The draft set plus a probe's `entityCounts`, keyed by the source's own entity names (a WordPress
+ * post type such as `product_brand`). `test` and `retest` answer the analysis at the top level,
+ * where no passthrough key covers it.
+ */
+export const PIPELINE_CONNECTION_PRESERVE_KEYS = new Set([
+    ...PIPELINE_DRAFT_PRESERVE_KEYS,
+    'entity_counts',
+    'entityCounts',
+]);
+const CONNECTIONS = '/pipelines/connections';
+const segment = (value) => encodeURIComponent(value);
+export function createPipelineConnectionsModule(transport) {
+    const call = (method, path, body, options, timeoutMs) => transport.rest('plugins', { method, path, ...(body === undefined ? {} : { body }) }, {
+        ...options,
+        preserveKeys: PIPELINE_CONNECTION_PRESERVE_KEYS,
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    });
+    async function list(options) {
+        const body = await transport.rest('plugins', {
+            method: 'GET',
+            path: CONNECTIONS,
+            query: { cursor: 1, after: options?.after, limit: options?.limit },
+        }, { ...options, preserveKeys: PIPELINE_CONNECTION_PRESERVE_KEYS });
+        const { items, meta } = readRestPage(body);
+        return createPage(items, meta, (cursor) => list({ ...options, after: cursor }));
+    }
+    return {
+        list,
+        async get(id, options) {
+            try {
+                return await call('GET', `${CONNECTIONS}/${segment(id)}`, undefined, options);
+            }
+            catch (error) {
+                if (error instanceof NotFoundError)
+                    return null;
+                throw error;
+            }
+        },
+        create: (input, options) => call('POST', CONNECTIONS, input, options, PIPELINE_DRAFT_SLOW_TIMEOUT_MS),
+        update: (id, input, options) => call('PATCH', `${CONNECTIONS}/${segment(id)}`, input, options, PIPELINE_DRAFT_SLOW_TIMEOUT_MS),
+        async delete(id, options) {
+            await transport.rest('plugins', { method: 'DELETE', path: `${CONNECTIONS}/${segment(id)}`, expect: 'void' }, options);
+        },
+        test: (input, options) => call('POST', `${CONNECTIONS}/test`, input, options, PIPELINE_DRAFT_SLOW_TIMEOUT_MS),
+        retest: (id, options) => call('POST', `${CONNECTIONS}/${segment(id)}/test`, undefined, options, PIPELINE_DRAFT_SLOW_TIMEOUT_MS),
+        detectConfig: (input, options) => call('POST', `${CONNECTIONS}/detect-config`, input, options, PIPELINE_DRAFT_SLOW_TIMEOUT_MS),
+    };
+}
+/** The connectors this deployment offers, `coming_soon` ones included. */
+export async function listPipelineConnectors(transport, options) {
+    return transport.rest('plugins', { method: 'GET', path: '/pipelines/connectors' }, { ...options, preserveKeys: PIPELINE_CONNECTION_PRESERVE_KEYS });
+}

package/dist/integrations/esp.d.ts

@@ -0,0 +1,313 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+/**
+ * State of the credentials the engine hands BACK to the e-mail platform (its read access to
+ * this store), as the connect handshake or a retry left it.
+ */
+export interface EspCredentialsPushState {
+    /** ISO-8601: when the platform accepted them. */
+    pushedAt?: string;
+    /** Why the platform refused them, in a sentence for staff. */
+    error?: string;
+    /** ISO-8601: the last attempt. */
+    attemptedAt?: string;
+    /** The first characters of the token handed over; never the token. */
+    tokenPrefix?: string;
+    adminApiUrl?: string;
+    /**
+     * Whether repeating could change the outcome. `false` for a contract or credential fault the
+     * same request would hit again: reconnect instead of retrying.
+     */
+    retryable?: boolean;
+    /** What the platform did with its first import: `queued` or `already_running`. */
+    initialSync?: string;
+}
+/**
+ * State of the REVERSE direction: the platform pushing suppressions, bounces, complaints and
+ * consent changes back to this engine. Soft like the credentials push: without it the engine
+ * still learns of them, 15 minutes later, from its reconcile poll.
+ */
+export interface EspInboundWebhookState {
+    registered: boolean;
+    subscriptionId?: string;
+    error?: string;
+    /** ISO-8601. */
+    at?: string;
+}
+/**
+ * What the one-paste connect handshake recorded; null on a connection configured by hand.
+ * Carries no secret. Every member is optional: an older connection recorded less.
+ */
+export interface EspConnectMetadata {
+    webhookUrl?: string;
+    events?: string[];
+    apiEndpoint?: string;
+    /** ISO-8601. */
+    connectedAt?: string;
+    pluginVersion?: string;
+    credentialsPush?: EspCredentialsPushState;
+    emailGateway?: {
+        provisioned: boolean;
+        skippedReason?: string;
+        at?: string;
+    };
+    inboundWebhook?: EspInboundWebhookState;
+}
+/**
+ * A store's connection to its e-mail marketing platform (sixtynine.email): one per store. The
+ * API key and webhook secret are never read back in any form.
+ */
+export interface EspConnection {
+    id: string;
+    channelId: string;
+    /** `sixtynine_email`, the one provider today. */
+    provider: string;
+    /** Whether the store's customers, orders, products and carts are sent. */
+    enabled: boolean;
+    /** The platform the store's data and stored key go to; a host the deployment allows. */
+    apiBaseUrl: string;
+    /** The store's id on the platform; null on a connection configured by hand without one. */
+    storeId: string | null;
+    defaultListId: string | null;
+    syncContacts: boolean;
+    syncOrders: boolean;
+    syncProducts: boolean;
+    syncCarts: boolean;
+    syncSubscriptions: boolean;
+    /** How long a cart sits unchanged before it is reported abandoned. */
+    cartIdleMinutes: number;
+    /** A cart last changed longer ago is never reported. */
+    cartMaxAgeDays: number;
+    /** How far back the first order import reaches. */
+    orderBackfillDays: number;
+    /** Platform field → store field, stored exactly as it was sent. */
+    fieldMappings: unknown;
+    connectMetadata: EspConnectMetadata | null;
+    /** ISO-8601. */
+    createdAt: string;
+    /** ISO-8601. */
+    updatedAt: string;
+}
+/**
+ * A PATCH: a key left out keeps the stored value. The first save must carry `apiBaseUrl`,
+ * `apiKey` and `webhookSecret` (`connectWithToken` is the one-paste way in). The two credentials
+ * are write-only: absent, null or empty keeps the stored one.
+ */
+export interface UpdateEspConnectionInput {
+    provider?: string;
+    enabled?: boolean;
+    apiBaseUrl?: string;
+    storeId?: string | null;
+    apiKey?: string | null;
+    webhookSecret?: string | null;
+    defaultListId?: string | null;
+    syncContacts?: boolean;
+    syncOrders?: boolean;
+    syncProducts?: boolean;
+    syncCarts?: boolean;
+    syncSubscriptions?: boolean;
+    cartIdleMinutes?: number;
+    /** At least 1, and longer than `cartIdleMinutes`. */
+    cartMaxAgeDays?: number;
+    orderBackfillDays?: number;
+    fieldMappings?: unknown;
+}
+/** The one-paste way in: where the platform lives, and the one-time token copied out of it. */
+export interface ConnectEspWithTokenInput {
+    apiBaseUrl: string;
+    connectToken: string;
+}
+/** What `test` found: a result, not a refusal. */
+export interface EspConnectionTestResult {
+    ok: boolean;
+    message: string;
+}
+/**
+ * What a backfill can send, in the order a full one sends it: products first, so order lines
+ * can match a product the platform already holds; customer groups before customers, because a
+ * group the platform first meets inside a customer has only its id and name. Pinned to the
+ * engine's list by this package's spec.
+ */
+export declare const ESP_BACKFILL_RESOURCES: readonly ["products", "customer_groups", "customers", "orders"];
+export type EspBackfillResource = (typeof ESP_BACKFILL_RESOURCES)[number];
+/**
+ * One attempt to send one record to the e-mail platform. The request the engine sent and the
+ * platform's raw answer are deliberately not read here: they carry the customer's personal data
+ * and are kept as audit evidence, not as an API.
+ */
+export interface EspSyncLog {
+    id: string;
+    channelId: string;
+    provider: string;
+    /** `customer`, `order`, `product`, `cart`, `subscription`, `customer_group`. */
+    entityType: string;
+    entityId: string;
+    /** The platform's reference for the record, when it answered one. */
+    externalRef: string | null;
+    /** The dotted event sent, e.g. `order.created`. */
+    eventType: string;
+    /** `pending`, `success`, `failed` or `skipped`; only a `failed` attempt can be retried. */
+    status: string;
+    /** The platform's HTTP status; null when it never answered. */
+    responseStatus: number | null;
+    /** Why it failed, in a sentence for staff; null otherwise. */
+    error: string | null;
+    attempt: number;
+    durationMs: number | null;
+    /** ISO-8601. */
+    createdAt: string;
+}
+/** Which attempts `syncLogs` lists; every member narrows, and none means all. */
+export interface EspSyncLogFilter {
+    entityType?: string;
+    entityId?: string;
+    status?: string;
+}
+/** The largest page `syncLogs` asks for; the default is 25. */
+export declare const ESP_SYNC_LOG_PAGE_LIMIT = 100;
+/**
+ * The store's e-mail marketing connection (sixtynine.email): connecting and configuring it,
+ * sending the store's history, and the log of what was sent (`admin.integrations.esp`). Always
+ * the store the client is scoped to; a SuperAdmin head acts on ANOTHER store with
+ * `admin.withTenant({ scope: { kind: 'channel', code } })`, or a per-call `tenant`.
+ *
+ * Every method needs `UpdateSettings` (the reads too: the engine guards them with the write's
+ * permission). An app installation is refused the connection lifecycle
+ * (`APP_CREDENTIAL_NOT_ALLOWED`), and a store without the e-mail marketing plugin every method
+ * (`PLUGIN_ACCESS_DENIED`, 403; never for a SuperAdmin).
+ */
+export interface EspModule {
+    /**
+     * The store's connection, or `null` when it has none.
+     *
+     * @effect read
+     * @permission UpdateSettings
+     */
+    connection(options?: Call): Promise<EspConnection | null>;
+    /**
+     * Configure the connection by hand; the first call creates it. Answers the saved connection.
+     *
+     * Refused, with nothing saved:
+     * - `ESP_INPUT_INVALID` (`ValidationError`, 400): a first save without `apiBaseUrl`, `apiKey`
+     *   or `webhookSecret`; an abandoned-cart window that can never report a cart; an explicit
+     *   null for a stored setting. `details[]` names each field;
+     * - `ESP_API_BASE_URL_INVALID` (400): a URL that is not https, carries credentials, or names a
+     *   host the deployment does not allow;
+     * - `ESP_HOST_CHANGE_REQUIRES_CREDENTIALS` (422): moving to another host without that host's
+     *   `apiKey` AND `webhookSecret` in the same call;
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` (422): switching on, or storing a credential, in an
+     *   organization's workspace.
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    update(input: UpdateEspConnectionInput, options?: Call): Promise<EspConnection>;
+    /**
+     * The one-paste way in: spend a one-time connect token at the platform for the store's
+     * credentials, store them, switch the connection on, and hand the platform back a read
+     * credential for this store, with which it starts importing the store's customers, orders and
+     * products. Answers the connection.
+     *
+     * The hand-back, the e-mail gateway and the inbound webhook are SOFT: a failure there still
+     * answers the (live) connection, with the reason in `connectMetadata.credentialsPush.error`,
+     * `.emailGateway.skippedReason` or `.inboundWebhook.error`. Read them: a resolved call is not
+     * a full success.
+     *
+     * Refused, with nothing saved: `ESP_INPUT_INVALID` (400, a blank token);
+     * `ESP_API_BASE_URL_INVALID` (400); `ESP_CONNECT_TOKEN_REJECTED` (422, the platform refused
+     * the token: unknown, used, expired, or too many attempts; the sentence says which);
+     * `ESP_PROVIDER_UNAVAILABLE` (422, the platform could not be reached or answered something
+     * unusable; the token may still be good); `ORGANIZATION_WORKSPACE_NOT_A_STORE` (422).
+     *
+     * @effect irreversible
+     * @permission UpdateSettings
+     */
+    connectWithToken(input: ConnectEspWithTokenInput, options?: Call): Promise<EspConnection>;
+    /**
+     * Hand the platform a FRESH read credential for this store (the previous one is not resent:
+     * the engine never stores it). Soft like the connect: a refusal answers the connection with
+     * `connectMetadata.credentialsPush.error` set, and `.retryable` says whether repeating helps.
+     *
+     * Refused: `ESP_CONNECTION_NOT_FOUND` (404); `ESP_RECONNECT_REQUIRED` (422, a connection
+     * configured by hand has no store id on the platform).
+     *
+     * @effect irreversible
+     * @permission UpdateSettings
+     */
+    retryCredentialsPush(options?: Call): Promise<EspConnection>;
+    /**
+     * Ask the platform again to send suppressions, bounces, complaints and consent changes back
+     * to this store. Soft: a failure answers the connection with
+     * `connectMetadata.inboundWebhook.error` set.
+     *
+     * Refused: `ESP_CONNECTION_NOT_FOUND` (404).
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    retryInboundWebhook(options?: Call): Promise<EspConnection>;
+    /**
+     * Remove the store's connection: the platform is told to stop sending first, then the stored
+     * credentials are deleted. `true` when a connection was removed, `false` when there was none.
+     * A platform that cannot be told never blocks the removal.
+     *
+     * @effect destructive
+     * @permission UpdateSettings
+     */
+    delete(options?: Call): Promise<boolean>;
+    /**
+     * Ask the platform whether the stored credentials work. Never refuses for what it finds: no
+     * connection, or credentials the platform rejects, answers `ok: false` with the reason.
+     *
+     * @effect read
+     * @permission UpdateSettings
+     */
+    test(options?: Call): Promise<EspConnectionTestResult>;
+    /**
+     * Send the store's history to the platform, without firing its automations: the named
+     * resources, in {@link ESP_BACKFILL_RESOURCES} order whatever order they are named in, or
+     * every resource when none are named. Each resource goes only while its sync is on
+     * (`syncProducts`, `syncContacts` for customers and groups, `syncOrders`). Queued: the call
+     * answers once the work is queued, and the sync log shows each record.
+     *
+     * It sends personal data (the customer list) to a third party, which cannot be taken back.
+     *
+     * Refused, with nothing queued: `ESP_INPUT_INVALID` (400, an empty list, or a resource the
+     * backfill does not know); `ESP_CONNECTION_NOT_FOUND` (404); `ESP_CONNECTION_DISABLED` (422).
+     *
+     * @effect irreversible
+     * @permission UpdateSettings
+     */
+    backfill(resources?: readonly EspBackfillResource[], options?: Call): Promise<void>;
+    /**
+     * The attempts to send this store's records, newest first, 25 to a page (at most
+     * {@link ESP_SYNC_LOG_PAGE_LIMIT}).
+     *
+     * @effect read
+     * @permission UpdateSettings
+     */
+    syncLogs(filter?: EspSyncLogFilter & ListOptions): Promise<Page<EspSyncLog>>;
+    /**
+     * Queue a FAILED attempt again, rebuilt from what it recorded. Answers the attempt retried
+     * (its row is not changed; the new attempt gets a row of its own).
+     *
+     * Refused, with nothing queued: `ESP_SYNC_LOG_NOT_FOUND` (404, not this store's);
+     * `ESP_SYNC_NOT_RETRYABLE` (422, the attempt did not fail); `ESP_SYNC_RETRY_NOT_POSSIBLE` (422,
+     * it failed but cannot be rebuilt; the sentence says what to do by hand).
+     *
+     * @effect irreversible
+     * @permission UpdateSettings
+     */
+    retrySync(syncLogId: string, options?: Call): Promise<EspSyncLog>;
+}
+export declare const ESP_CONNECTION_QUERY = "\n  query EspConnection {\n    espConnection { \n  id\n  channelId\n  provider\n  enabled\n  apiBaseUrl\n  storeId\n  defaultListId\n  syncContacts\n  syncOrders\n  syncProducts\n  syncCarts\n  syncSubscriptions\n  cartIdleMinutes\n  cartMaxAgeDays\n  orderBackfillDays\n  fieldMappings\n  connectMetadata\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const UPDATE_ESP_CONNECTION_MUTATION = "\n  mutation UpdateEspConnection($input: UpdateEspConnectionInput!) {\n    updateEspConnection(input: $input) { \n  id\n  channelId\n  provider\n  enabled\n  apiBaseUrl\n  storeId\n  defaultListId\n  syncContacts\n  syncOrders\n  syncProducts\n  syncCarts\n  syncSubscriptions\n  cartIdleMinutes\n  cartMaxAgeDays\n  orderBackfillDays\n  fieldMappings\n  connectMetadata\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const CONNECT_ESP_WITH_TOKEN_MUTATION = "\n  mutation ConnectEspWithToken($input: ConnectEspWithTokenInput!) {\n    connectEspWithToken(input: $input) { \n  id\n  channelId\n  provider\n  enabled\n  apiBaseUrl\n  storeId\n  defaultListId\n  syncContacts\n  syncOrders\n  syncProducts\n  syncCarts\n  syncSubscriptions\n  cartIdleMinutes\n  cartMaxAgeDays\n  orderBackfillDays\n  fieldMappings\n  connectMetadata\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const RETRY_ESP_CREDENTIALS_PUSH_MUTATION = "\n  mutation RetryEspCredentialsPush {\n    retryEspCredentialsPush { \n  id\n  channelId\n  provider\n  enabled\n  apiBaseUrl\n  storeId\n  defaultListId\n  syncContacts\n  syncOrders\n  syncProducts\n  syncCarts\n  syncSubscriptions\n  cartIdleMinutes\n  cartMaxAgeDays\n  orderBackfillDays\n  fieldMappings\n  connectMetadata\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const RETRY_ESP_INBOUND_WEBHOOK_MUTATION = "\n  mutation RetryEspInboundWebhook {\n    retryEspInboundWebhook { \n  id\n  channelId\n  provider\n  enabled\n  apiBaseUrl\n  storeId\n  defaultListId\n  syncContacts\n  syncOrders\n  syncProducts\n  syncCarts\n  syncSubscriptions\n  cartIdleMinutes\n  cartMaxAgeDays\n  orderBackfillDays\n  fieldMappings\n  connectMetadata\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const DELETE_ESP_CONNECTION_MUTATION = "\n  mutation DeleteEspConnection {\n    deleteEspConnection\n  }\n";
+export declare const TEST_ESP_CONNECTION_MUTATION = "\n  mutation TestEspConnection {\n    testEspConnection { ok message }\n  }\n";
+export declare const TRIGGER_ESP_BACKFILL_MUTATION = "\n  mutation TriggerMarketingBackfill($resources: [String!]) {\n    triggerMarketingBackfill(resources: $resources)\n  }\n";
+export declare const ESP_SYNC_LOGS_QUERY = "\n  query EspSyncLogs($options: EspSyncLogListOptions) {\n    espSyncLogs(options: $options) {\n      items { \n  id\n  channelId\n  provider\n  entityType\n  entityId\n  externalRef\n  eventType\n  status\n  responseStatus\n  error\n  attempt\n  durationMs\n  createdAt\n }\n      totalItems\n    }\n  }\n";
+export declare const RETRY_ESP_SYNC_MUTATION = "\n  mutation RetryEspSync($syncLogId: ID!) {\n    retryEspSync(syncLogId: $syncLogId) { \n  id\n  channelId\n  provider\n  entityType\n  entityId\n  externalRef\n  eventType\n  status\n  responseStatus\n  error\n  attempt\n  durationMs\n  createdAt\n }\n  }\n";
+export declare function createEspModule(transport: Transport): EspModule;

package/dist/integrations/esp.js

@@ -0,0 +1,169 @@
+import { pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+/**
+ * What a backfill can send, in the order a full one sends it: products first, so order lines
+ * can match a product the platform already holds; customer groups before customers, because a
+ * group the platform first meets inside a customer has only its id and name. Pinned to the
+ * engine's list by this package's spec.
+ */
+export const ESP_BACKFILL_RESOURCES = [
+    'products',
+    'customer_groups',
+    'customers',
+    'orders',
+];
+/** The largest page `syncLogs` asks for; the default is 25. */
+export const ESP_SYNC_LOG_PAGE_LIMIT = 100;
+const ESP_SYNC_LOG_PAGE_SIZE = 25;
+const CONNECTION_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  provider
+  enabled
+  apiBaseUrl
+  storeId
+  defaultListId
+  syncContacts
+  syncOrders
+  syncProducts
+  syncCarts
+  syncSubscriptions
+  cartIdleMinutes
+  cartMaxAgeDays
+  orderBackfillDays
+  fieldMappings
+  connectMetadata
+  createdAt
+  updatedAt
+`;
+const SYNC_LOG_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  provider
+  entityType
+  entityId
+  externalRef
+  eventType
+  status
+  responseStatus
+  error
+  attempt
+  durationMs
+  createdAt
+`;
+export const ESP_CONNECTION_QUERY = /* GraphQL */ `
+  query EspConnection {
+    espConnection { ${CONNECTION_FIELDS} }
+  }
+`;
+export const UPDATE_ESP_CONNECTION_MUTATION = /* GraphQL */ `
+  mutation UpdateEspConnection($input: UpdateEspConnectionInput!) {
+    updateEspConnection(input: $input) { ${CONNECTION_FIELDS} }
+  }
+`;
+export const CONNECT_ESP_WITH_TOKEN_MUTATION = /* GraphQL */ `
+  mutation ConnectEspWithToken($input: ConnectEspWithTokenInput!) {
+    connectEspWithToken(input: $input) { ${CONNECTION_FIELDS} }
+  }
+`;
+export const RETRY_ESP_CREDENTIALS_PUSH_MUTATION = /* GraphQL */ `
+  mutation RetryEspCredentialsPush {
+    retryEspCredentialsPush { ${CONNECTION_FIELDS} }
+  }
+`;
+export const RETRY_ESP_INBOUND_WEBHOOK_MUTATION = /* GraphQL */ `
+  mutation RetryEspInboundWebhook {
+    retryEspInboundWebhook { ${CONNECTION_FIELDS} }
+  }
+`;
+export const DELETE_ESP_CONNECTION_MUTATION = /* GraphQL */ `
+  mutation DeleteEspConnection {
+    deleteEspConnection
+  }
+`;
+export const TEST_ESP_CONNECTION_MUTATION = /* GraphQL */ `
+  mutation TestEspConnection {
+    testEspConnection { ok message }
+  }
+`;
+export const TRIGGER_ESP_BACKFILL_MUTATION = /* GraphQL */ `
+  mutation TriggerMarketingBackfill($resources: [String!]) {
+    triggerMarketingBackfill(resources: $resources)
+  }
+`;
+export const ESP_SYNC_LOGS_QUERY = /* GraphQL */ `
+  query EspSyncLogs($options: EspSyncLogListOptions) {
+    espSyncLogs(options: $options) {
+      items { ${SYNC_LOG_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const RETRY_ESP_SYNC_MUTATION = /* GraphQL */ `
+  mutation RetryEspSync($syncLogId: ID!) {
+    retryEspSync(syncLogId: $syncLogId) { ${SYNC_LOG_FIELDS} }
+  }
+`;
+export function createEspModule(transport) {
+    const connectionMutation = async (query, field, variables, options) => {
+        const data = await transport.graphql({ api: 'admin', query, ...(variables ? { variables } : {}) }, options);
+        const connection = data[field];
+        if (!connection)
+            throw new Error(`The engine answered no ${field}`);
+        return connection;
+    };
+    const syncLogPage = async (filter, skip, take, options) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: ESP_SYNC_LOGS_QUERY,
+            variables: { options: { ...filter, skip, take } },
+        }, options);
+        return pageFromVendureList(data.espSyncLogs, skip, take, (cursor) => syncLogPage(filter, readOffsetCursor(cursor), take, options));
+    };
+    return {
+        async connection(options) {
+            const data = await transport.graphql({ api: 'admin', query: ESP_CONNECTION_QUERY }, options);
+            return data.espConnection ?? null;
+        },
+        update(input, options) {
+            // Sent as given: an absent key keeps the stored value, and the engine names anything it
+            // refuses.
+            return connectionMutation(UPDATE_ESP_CONNECTION_MUTATION, 'updateEspConnection', { input }, options);
+        },
+        connectWithToken(input, options) {
+            return connectionMutation(CONNECT_ESP_WITH_TOKEN_MUTATION, 'connectEspWithToken', { input }, options);
+        },
+        retryCredentialsPush(options) {
+            return connectionMutation(RETRY_ESP_CREDENTIALS_PUSH_MUTATION, 'retryEspCredentialsPush', undefined, options);
+        },
+        retryInboundWebhook(options) {
+            return connectionMutation(RETRY_ESP_INBOUND_WEBHOOK_MUTATION, 'retryEspInboundWebhook', undefined, options);
+        },
+        async delete(options) {
+            const data = await transport.graphql({ api: 'admin', query: DELETE_ESP_CONNECTION_MUTATION }, options);
+            return data.deleteEspConnection === true;
+        },
+        async test(options) {
+            const data = await transport.graphql({ api: 'admin', query: TEST_ESP_CONNECTION_MUTATION }, options);
+            return data.testEspConnection;
+        },
+        async backfill(resources, options) {
+            // `undefined` stays off the wire (every resource); a list goes as given, an empty one
+            // included, so the engine is the one that refuses it.
+            await transport.graphql({
+                api: 'admin',
+                query: TRIGGER_ESP_BACKFILL_MUTATION,
+                variables: { resources: resources === undefined ? undefined : [...resources] },
+            }, options);
+        },
+        syncLogs(filter) {
+            const { after, limit, entityType, entityId, status, ...options } = filter ?? {};
+            const take = Math.min(Math.max(limit ?? ESP_SYNC_LOG_PAGE_SIZE, 1), ESP_SYNC_LOG_PAGE_LIMIT);
+            const skip = after === undefined ? 0 : readOffsetCursor(after);
+            return syncLogPage({ entityType, entityId, status }, skip, take, options);
+        },
+        async retrySync(syncLogId, options) {
+            const data = await transport.graphql({ api: 'admin', query: RETRY_ESP_SYNC_MUTATION, variables: { syncLogId } }, options);
+            return data.retryEspSync;
+        },
+    };
+}