@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/pickups/index.js

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

package/dist/platform/channels.d.ts

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

package/dist/platform/channels.js

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

package/dist/platform/email-gateways.d.ts

@@ -0,0 +1,165 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { AdminClientConfig } from '../client.js';
+import type { Call } from '../types.js';
+/** How a gateway sends: an SMTP server, or the sixtynine.email HTTP API. Fixed at creation. */
+export type EmailGatewayType = 'smtp' | 'sixtynine_email';
+/**
+ * A store's email gateway: the way its transactional email leaves the platform. One per store at
+ * most; a store without one sends through the platform's default sender.
+ *
+ * Credentials (the SMTP password, the sixtynine.email API key) are write-only and never read back.
+ */
+export interface EmailGateway {
+    id: string;
+    /** The store (channel id) it sends for. */
+    channelId: string;
+    type: EmailGatewayType;
+    name: string;
+    /** SMTP only; `null` on a sixtynine.email gateway. */
+    host: string | null;
+    /** SMTP only; `null` on a sixtynine.email gateway. */
+    port: number | null;
+    /** SMTP only; `null` for an unauthenticated relay or a sixtynine.email gateway. */
+    username: string | null;
+    fromAddress: string;
+    fromName: string;
+    /**
+     * SMTP only: `tls` (TLS from the first byte, usually port 465), `starttls` (a plain connection
+     * that must upgrade to TLS, usually port 587) or `none`. `null` on a sixtynine.email gateway.
+     */
+    encryption: string | null;
+    /** sixtynine.email only: the API's address, such as `https://sixtynine.email`. */
+    apiUrl: string | null;
+    /** A disabled gateway is skipped: its store sends through the platform's default sender. */
+    enabled: boolean;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    /** ISO-8601 UTC. */
+    updatedAt: string;
+}
+/**
+ * A new gateway. `type` decides which fields apply: an SMTP gateway (the default) needs `host` and
+ * `password`; a sixtynine.email gateway needs `apiKey`. The other type's fields are ignored.
+ */
+export interface CreateEmailGatewayInput {
+    channelId: string;
+    /** Default `smtp`. */
+    type?: EmailGatewayType;
+    name: string;
+    host?: string;
+    /** 1–65535; default 587. */
+    port?: number;
+    username?: string;
+    /** Write-only. */
+    password?: string;
+    /**
+     * `tls`, `starttls` or `none`. Left out: `tls` on port 465, `starttls` on any other. Any other
+     * letter case of `TLS`/`STARTTLS` is stored by the port (465 → `tls`, else `starttls`).
+     */
+    encryption?: string;
+    /**
+     * An https:// address on one of the platform's sixtynine.email hosts (such as
+     * `https://sixtynine.email`), with no user name, query or fragment: the API key is sent there.
+     * Left out, none is stored and the gateway sends nothing until one is set.
+     */
+    apiUrl?: string;
+    /** Write-only. */
+    apiKey?: string;
+    fromAddress: string;
+    fromName: string;
+}
+/**
+ * A change to a gateway. A field left out keeps what the gateway has; `password` and `apiKey`
+ * left out or empty keep the stored credential. The type cannot change: the SMTP fields are
+ * ignored on a sixtynine.email gateway, and `apiUrl`/`apiKey` on an SMTP one.
+ */
+export interface UpdateEmailGatewayInput {
+    /** Moves the gateway to another store. */
+    channelId?: string;
+    name?: string;
+    host?: string;
+    port?: number;
+    /** `null` clears it (an unauthenticated relay). */
+    username?: string | null;
+    password?: string;
+    encryption?: string;
+    /** `null` clears it: the gateway then sends nothing. */
+    apiUrl?: string | null;
+    apiKey?: string;
+    fromAddress?: string;
+    fromName?: string;
+    enabled?: boolean;
+}
+/**
+ * `admin.platform.emailGateways` — the stores' email gateways, for platform staff (spec §9.2
+ * `platform`). Gateways of every store, so no tenant is needed on the client.
+ *
+ * Every method needs a human SuperAdmin session: an API token or an app credential is refused
+ * with `PLATFORM_REQUIRES_SESSION` (`PermissionDeniedError`, 403) BEFORE anything is sent, and a
+ * session without SuperAdmin is refused by the engine (`FORBIDDEN`).
+ *
+ * **Coded refusals** (GraphQL errors mapped by `core`):
+ * - `EMAIL_GATEWAY_INPUT_INVALID` → `ValidationError` (400): a value the gateway cannot use. Every
+ *   problem of one save comes back at once in `details[]` (`field` names the input property, e.g.
+ *   `apiUrl`), and no refusal repeats a value it was sent (a password put in the wrong field
+ *   never comes back).
+ * - `EMAIL_GATEWAY_NOT_FOUND` → `NotFoundError` (404): no gateway has that id.
+ * - `EMAIL_GATEWAY_CHANNEL_TAKEN` → `ConflictError` (409): the store already has a gateway.
+ * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` → `BusinessRuleError` (422): a workspace's channel is
+ *   not a store; moving a gateway there, enabling one there or storing a credential on it is
+ *   refused.
+ * - `EMAIL_GATEWAY_TEST_FAILED` → `BusinessRuleError` (422): see {@link test}.
+ * - `EMAIL_GATEWAY_TEST_NOT_SUPPORTED` → `BusinessRuleError` (422): see {@link test}.
+ */
+export interface PlatformEmailGatewaysModule {
+    /**
+     * Every store's gateway, newest first.
+     *
+     * @effect read
+     */
+    list(options?: Call): Promise<EmailGateway[]>;
+    /**
+     * One gateway, or `null` when no gateway has that id.
+     *
+     * @effect read
+     */
+    get(id: string, options?: Call): Promise<EmailGateway | null>;
+    /**
+     * Create a store's gateway, enabled, and answer it as read.
+     *
+     * @effect write
+     */
+    create(input: CreateEmailGatewayInput, options?: Call): Promise<EmailGateway>;
+    /**
+     * Change a gateway, and answer it as read.
+     *
+     * @effect write
+     */
+    update(id: string, patch: UpdateEmailGatewayInput, options?: Call): Promise<EmailGateway>;
+    /**
+     * Delete a gateway. Its store then sends through the platform's default sender.
+     *
+     * @effect destructive
+     */
+    delete(id: string, options?: Call): Promise<void>;
+    /**
+     * Check that an SMTP gateway's server takes a connection with its stored settings and
+     * credentials. No email is sent. Resolves when the check passed.
+     *
+     * - `EMAIL_GATEWAY_TEST_FAILED`: the server refused or could not be reached. The message names
+     *   the step that failed (TLS handshake, user name or password, host name, timeout,
+     *   connection), never the server's own reply.
+     * - `EMAIL_GATEWAY_TEST_NOT_SUPPORTED`: a sixtynine.email gateway; the check is SMTP-only.
+     * - `EMAIL_GATEWAY_NOT_FOUND`: no gateway has that id.
+     *
+     * @effect read
+     */
+    test(id: string, options?: Call): Promise<void>;
+}
+export declare const EMAIL_GATEWAYS_QUERY = "\n  query PlatformEmailGateways {\n    emailGateways { \n  id\n  channelId\n  type\n  name\n  host\n  port\n  username\n  fromAddress\n  fromName\n  encryption\n  apiUrl\n  enabled\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const EMAIL_GATEWAY_QUERY = "\n  query PlatformEmailGateway($id: ID!) {\n    emailGateway(id: $id) { \n  id\n  channelId\n  type\n  name\n  host\n  port\n  username\n  fromAddress\n  fromName\n  encryption\n  apiUrl\n  enabled\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const CREATE_EMAIL_GATEWAY_MUTATION = "\n  mutation PlatformCreateEmailGateway($input: CreateEmailGatewayInput!) {\n    createEmailGateway(input: $input) { \n  id\n  channelId\n  type\n  name\n  host\n  port\n  username\n  fromAddress\n  fromName\n  encryption\n  apiUrl\n  enabled\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const UPDATE_EMAIL_GATEWAY_MUTATION = "\n  mutation PlatformUpdateEmailGateway($id: ID!, $input: UpdateEmailGatewayInput!) {\n    updateEmailGateway(id: $id, input: $input) { \n  id\n  channelId\n  type\n  name\n  host\n  port\n  username\n  fromAddress\n  fromName\n  encryption\n  apiUrl\n  enabled\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const DELETE_EMAIL_GATEWAY_MUTATION = "\n  mutation PlatformDeleteEmailGateway($id: ID!) {\n    deleteEmailGateway(id: $id) { result }\n  }\n";
+export declare const TEST_EMAIL_GATEWAY_MUTATION = "\n  mutation PlatformTestEmailGateway($id: ID!) {\n    testEmailGateway(id: $id)\n  }\n";
+export declare function createPlatformEmailGatewaysModule(transport: Transport, config: AdminClientConfig): PlatformEmailGatewaysModule;

package/dist/platform/email-gateways.js

@@ -0,0 +1,78 @@
+import { fieldOf } from '../catalog/types.js';
+import { requireHumanSession } from './guard.js';
+const GATEWAY_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  type
+  name
+  host
+  port
+  username
+  fromAddress
+  fromName
+  encryption
+  apiUrl
+  enabled
+  createdAt
+  updatedAt
+`;
+export const EMAIL_GATEWAYS_QUERY = /* GraphQL */ `
+  query PlatformEmailGateways {
+    emailGateways { ${GATEWAY_FIELDS} }
+  }
+`;
+export const EMAIL_GATEWAY_QUERY = /* GraphQL */ `
+  query PlatformEmailGateway($id: ID!) {
+    emailGateway(id: $id) { ${GATEWAY_FIELDS} }
+  }
+`;
+export const CREATE_EMAIL_GATEWAY_MUTATION = /* GraphQL */ `
+  mutation PlatformCreateEmailGateway($input: CreateEmailGatewayInput!) {
+    createEmailGateway(input: $input) { ${GATEWAY_FIELDS} }
+  }
+`;
+export const UPDATE_EMAIL_GATEWAY_MUTATION = /* GraphQL */ `
+  mutation PlatformUpdateEmailGateway($id: ID!, $input: UpdateEmailGatewayInput!) {
+    updateEmailGateway(id: $id, input: $input) { ${GATEWAY_FIELDS} }
+  }
+`;
+export const DELETE_EMAIL_GATEWAY_MUTATION = /* GraphQL */ `
+  mutation PlatformDeleteEmailGateway($id: ID!) {
+    deleteEmailGateway(id: $id) { result }
+  }
+`;
+export const TEST_EMAIL_GATEWAY_MUTATION = /* GraphQL */ `
+  mutation PlatformTestEmailGateway($id: ID!) {
+    testEmailGateway(id: $id)
+  }
+`;
+export function createPlatformEmailGatewaysModule(transport, config) {
+    // Gateways of every store: no store is involved, so no tenant is needed (as `platform.tax`).
+    const unscoped = (call) => ({ ...call, allowUnscoped: true });
+    return {
+        async list(options) {
+            requireHumanSession(config);
+            return fieldOf(transport, EMAIL_GATEWAYS_QUERY, 'emailGateways', {}, unscoped(options));
+        },
+        async get(id, options) {
+            requireHumanSession(config);
+            return fieldOf(transport, EMAIL_GATEWAY_QUERY, 'emailGateway', { id }, unscoped(options));
+        },
+        async create(input, options) {
+            requireHumanSession(config);
+            return fieldOf(transport, CREATE_EMAIL_GATEWAY_MUTATION, 'createEmailGateway', { input }, unscoped(options));
+        },
+        async update(id, patch, options) {
+            requireHumanSession(config);
+            return fieldOf(transport, UPDATE_EMAIL_GATEWAY_MUTATION, 'updateEmailGateway', { id, input: patch }, unscoped(options));
+        },
+        async delete(id, options) {
+            requireHumanSession(config);
+            await fieldOf(transport, DELETE_EMAIL_GATEWAY_MUTATION, 'deleteEmailGateway', { id }, unscoped(options));
+        },
+        async test(id, options) {
+            requireHumanSession(config);
+            await fieldOf(transport, TEST_EMAIL_GATEWAY_MUTATION, 'testEmailGateway', { id }, unscoped(options));
+        },
+    };
+}