@sixtyninecommerce/admin 0.10.0 → 0.11.0

package/dist/payments/payment-links.d.ts

@@ -0,0 +1,180 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * A store's payment-links connection (Tikkie, ABN AMRO): one record per store. It adds a "pay
+ * this invoice" link to the invoice e-mails of orders with something left to pay, and the order
+ * settles when the link is paid. The credentials are never read back, only whether one is stored
+ * and its mask.
+ */
+export interface PaymentLinksConfig {
+    id: string;
+    channelId: string;
+    /** `tikkie`, the one provider today. */
+    provider: string;
+    /** Whether new invoice e-mails carry a link. Never true without an app token. */
+    enabled: boolean;
+    /** Talks to the Tikkie sandbox instead of production. */
+    sandboxMode: boolean;
+    /** Days a new link stays payable. */
+    defaultExpiryDays: number;
+    hasApiKey: boolean;
+    /** The stored API key, masked (its last four characters); null when none, or unreadable. */
+    maskedApiKey: string | null;
+    hasAppToken: boolean;
+    /** The stored app token, masked; null when none, or unreadable. */
+    maskedAppToken: string | null;
+    /** Tikkie's id of the store's webhook subscription; null until one is registered. */
+    webhookSubscriptionId: string | null;
+    /** ISO-8601: when the webhook was registered; null until it is. */
+    webhookRegisteredAt: string | null;
+    /** ISO-8601. */
+    createdAt: string;
+    /** ISO-8601. */
+    updatedAt: string;
+}
+/**
+ * A PATCH: a key left out keeps the stored value. The first save must carry `apiKey`.
+ *
+ * A credential is write-only. Absent, null, blank, or the very mask the read answered keeps the
+ * stored one; any other value carrying the mask glyph is refused `SECRET_ARG_MASK_INVALID`.
+ */
+export interface UpdatePaymentLinksConfigInput {
+    enabled?: boolean;
+    sandboxMode?: boolean;
+    /** No range is enforced: 0 or less makes links that have already expired. */
+    defaultExpiryDays?: number;
+    apiKey?: string | null;
+    appToken?: string | null;
+}
+/** What `testConnection` found: a result, not a refusal. */
+export interface PaymentLinksTestResult {
+    ok: boolean;
+    /** A sentence for the person who pressed "Test": the HTTP status at most, never Tikkie's body. */
+    message: string;
+}
+/** Every state a payment link takes, in the engine's order (`PaymentRequestStatus`). */
+export declare const PAYMENT_LINK_REQUEST_STATUSES: readonly ["open", "paid", "expired", "superseded"];
+/**
+ * `open`, then `paid` or `expired`; `superseded` when a newer link for the same order replaced it.
+ * A later engine may add a state: read anything else as "not payable".
+ */
+export type PaymentLinkRequestStatus = (typeof PAYMENT_LINK_REQUEST_STATUSES)[number] | (string & {});
+/**
+ * One Tikkie payment link the store sent for an order. Not the engine's own hosted payment
+ * request (`payments.requests`): this is the payment-links plugin's, created by the invoice
+ * e-mail.
+ */
+export interface PaymentLinkRequest {
+    id: string;
+    orderId: string;
+    /** The invoice whose e-mail carried the link; null for a link sent otherwise. */
+    invoiceId: string | null;
+    provider: string;
+    /** The provider's id of the request (Tikkie's payment request token). */
+    externalId: string;
+    /** The link the customer pays through. */
+    url: string;
+    status: PaymentLinkRequestStatus;
+    /** Minor units of `currencyCode` the link asks for. */
+    amountMinor: number;
+    currencyCode: string;
+    /** ISO-8601; null when the provider set none. */
+    expiresAt: string | null;
+    /** ISO-8601; null until paid. */
+    paidAt: string | null;
+    /** ISO-8601. */
+    createdAt: string;
+}
+/** The store's Tikkie settings (`admin.payments.paymentLinks.config`). */
+export interface PaymentLinksConfigModule {
+    /**
+     * The store's settings, or `null` when it never saved any. Needs `UpdateSettings` (the engine
+     * guards the read with the write's permission).
+     *
+     * @effect read
+     * @permission UpdateSettings
+     */
+    get(options?: Call): Promise<PaymentLinksConfig | null>;
+    /**
+     * Save the settings; the first call creates the record (off, sandbox mode, 14-day links,
+     * unless given). Needs `UpdateSettings`.
+     *
+     * Refused, with nothing saved:
+     * - `PAYMENT_LINKS_INPUT_INVALID` (`ValidationError`, 400): the first save without `apiKey`, or
+     *   an explicit null for `enabled`, `sandboxMode` or `defaultExpiryDays` on a saved record.
+     *   `details[]` names each field;
+     * - `PAYMENT_LINKS_APP_TOKEN_REQUIRED` (`BusinessRuleError`, 422): `enabled: true` while no app
+     *   token is stored or sent in the same call;
+     * - `SECRET_ARG_MASK_INVALID` (400): a credential carrying the mask glyph that is not the stored
+     *   one's mask; `APP_SECRET_ARG_NOT_ALLOWED` (403): an app installation setting a credential;
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` (422): switching on, or storing a credential, in an
+     *   organization's workspace;
+     * - `PLUGIN_ACCESS_DENIED` (403): the store does not hold the payment-links plugin (never for a
+     *   SuperAdmin).
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    update(input: UpdatePaymentLinksConfigInput, options?: Call): Promise<PaymentLinksConfig>;
+}
+/**
+ * The store's payment links: the Tikkie connection's settings, its checks, and the links an
+ * order was sent (`admin.payments.paymentLinks`). Always the store the client is scoped to; a
+ * SuperAdmin head configures ANOTHER store with `admin.withTenant({ scope: { kind: 'channel',
+ * code } })`, or a per-call `tenant`.
+ */
+export interface PaymentLinksModule {
+    config: PaymentLinksConfigModule;
+    /**
+     * Ask Tikkie whether the stored credentials work. Never refuses for what it finds: a store with
+     * no settings, no app token, or credentials Tikkie rejects answers `ok: false` with the reason.
+     * Needs `UpdateSettings`.
+     *
+     * @effect read
+     * @permission UpdateSettings
+     */
+    testConnection(options?: Call): Promise<PaymentLinksTestResult>;
+    /**
+     * Register the store's webhook with Tikkie, so a paid link settles its order at once instead of
+     * at the 5-minute check, and answer the settings with the subscription. Needs `UpdateSettings`.
+     *
+     * Refused: `PAYMENT_LINKS_NOT_CONFIGURED` (422) without settings;
+     * `PAYMENT_LINKS_APP_TOKEN_REQUIRED` (422) with no app token stored;
+     * `PAYMENT_LINKS_PROVIDER_UNAVAILABLE` (422, Tikkie failed or refused; nothing stored);
+     * `PAYMENT_LINKS_WEBHOOK_HOST_NOT_CONFIGURED` (422, the platform has no public address; its
+     * operator's to fix); `ORGANIZATION_WORKSPACE_NOT_A_STORE` (422).
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    registerWebhook(options?: Call): Promise<PaymentLinksConfig>;
+    /**
+     * Sandbox only: have Tikkie mint a test app token with the stored API key, store it, and answer
+     * the settings. Needs `UpdateSettings`; an app installation is refused
+     * (`APP_SECRET_ARG_NOT_ALLOWED`).
+     *
+     * Refused: `PAYMENT_LINKS_NOT_CONFIGURED` (422); `PAYMENT_LINKS_SANDBOX_MODE_REQUIRED` (422,
+     * the store is in production mode); `PAYMENT_LINKS_PROVIDER_UNAVAILABLE` (422, nothing stored);
+     * `ORGANIZATION_WORKSPACE_NOT_A_STORE` (422).
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    createSandboxAppToken(options?: Call): Promise<PaymentLinksConfig>;
+    /**
+     * The payment links the store sent for one order, newest first. Needs `ReadOrder`. Another
+     * store's order, or an id that names no order, answers an empty list; a value that is no id
+     * at all is refused `ENTITY_NOT_FOUND` (`NotFoundError`, 404).
+     *
+     * @effect read
+     * @permission ReadOrder
+     */
+    requests(orderId: string, options?: Call): Promise<PaymentLinkRequest[]>;
+}
+export declare const PAYMENT_LINKS_CONFIG_QUERY = "\n  query PaymentLinksConfig {\n    paymentLinksConfig { \n  id\n  channelId\n  provider\n  enabled\n  sandboxMode\n  defaultExpiryDays\n  hasApiKey\n  maskedApiKey\n  hasAppToken\n  maskedAppToken\n  webhookSubscriptionId\n  webhookRegisteredAt\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const UPDATE_PAYMENT_LINKS_CONFIG_MUTATION = "\n  mutation UpdatePaymentLinksConfig($input: UpdatePaymentLinksConfigInput!) {\n    updatePaymentLinksConfig(input: $input) { \n  id\n  channelId\n  provider\n  enabled\n  sandboxMode\n  defaultExpiryDays\n  hasApiKey\n  maskedApiKey\n  hasAppToken\n  maskedAppToken\n  webhookSubscriptionId\n  webhookRegisteredAt\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const TEST_PAYMENT_LINKS_CONNECTION_MUTATION = "\n  mutation TestPaymentLinksConnection {\n    testPaymentLinksConnection { ok message }\n  }\n";
+export declare const REGISTER_PAYMENT_LINKS_WEBHOOK_MUTATION = "\n  mutation RegisterPaymentLinksWebhook {\n    registerPaymentLinksWebhook { \n  id\n  channelId\n  provider\n  enabled\n  sandboxMode\n  defaultExpiryDays\n  hasApiKey\n  maskedApiKey\n  hasAppToken\n  maskedAppToken\n  webhookSubscriptionId\n  webhookRegisteredAt\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const CREATE_PAYMENT_LINKS_SANDBOX_APP_TOKEN_MUTATION = "\n  mutation CreatePaymentLinksSandboxAppToken {\n    createPaymentLinksSandboxAppToken { \n  id\n  channelId\n  provider\n  enabled\n  sandboxMode\n  defaultExpiryDays\n  hasApiKey\n  maskedApiKey\n  hasAppToken\n  maskedAppToken\n  webhookSubscriptionId\n  webhookRegisteredAt\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const ORDER_PAYMENT_LINK_REQUESTS_QUERY = "\n  query OrderPaymentLinkRequests($orderId: ID!) {\n    orderPaymentLinkRequests(orderId: $orderId) {\n      id\n      orderId\n      invoiceId\n      provider\n      externalId\n      url\n      status\n      amountMinor\n      currencyCode\n      expiresAt\n      paidAt\n      createdAt\n    }\n  }\n";
+export declare function createPaymentLinksModule(transport: Transport): PaymentLinksModule;

package/dist/payments/payment-links.js

@@ -0,0 +1,97 @@
+/** Every state a payment link takes, in the engine's order (`PaymentRequestStatus`). */
+export const PAYMENT_LINK_REQUEST_STATUSES = ['open', 'paid', 'expired', 'superseded'];
+const CONFIG_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  provider
+  enabled
+  sandboxMode
+  defaultExpiryDays
+  hasApiKey
+  maskedApiKey
+  hasAppToken
+  maskedAppToken
+  webhookSubscriptionId
+  webhookRegisteredAt
+  createdAt
+  updatedAt
+`;
+export const PAYMENT_LINKS_CONFIG_QUERY = /* GraphQL */ `
+  query PaymentLinksConfig {
+    paymentLinksConfig { ${CONFIG_FIELDS} }
+  }
+`;
+export const UPDATE_PAYMENT_LINKS_CONFIG_MUTATION = /* GraphQL */ `
+  mutation UpdatePaymentLinksConfig($input: UpdatePaymentLinksConfigInput!) {
+    updatePaymentLinksConfig(input: $input) { ${CONFIG_FIELDS} }
+  }
+`;
+export const TEST_PAYMENT_LINKS_CONNECTION_MUTATION = /* GraphQL */ `
+  mutation TestPaymentLinksConnection {
+    testPaymentLinksConnection { ok message }
+  }
+`;
+export const REGISTER_PAYMENT_LINKS_WEBHOOK_MUTATION = /* GraphQL */ `
+  mutation RegisterPaymentLinksWebhook {
+    registerPaymentLinksWebhook { ${CONFIG_FIELDS} }
+  }
+`;
+export const CREATE_PAYMENT_LINKS_SANDBOX_APP_TOKEN_MUTATION = /* GraphQL */ `
+  mutation CreatePaymentLinksSandboxAppToken {
+    createPaymentLinksSandboxAppToken { ${CONFIG_FIELDS} }
+  }
+`;
+export const ORDER_PAYMENT_LINK_REQUESTS_QUERY = /* GraphQL */ `
+  query OrderPaymentLinkRequests($orderId: ID!) {
+    orderPaymentLinkRequests(orderId: $orderId) {
+      id
+      orderId
+      invoiceId
+      provider
+      externalId
+      url
+      status
+      amountMinor
+      currencyCode
+      expiresAt
+      paidAt
+      createdAt
+    }
+  }
+`;
+export function createPaymentLinksModule(transport) {
+    return {
+        config: {
+            async get(options) {
+                const data = await transport.graphql({ api: 'admin', query: PAYMENT_LINKS_CONFIG_QUERY }, options);
+                return data.paymentLinksConfig ?? null;
+            },
+            async update(input, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: UPDATE_PAYMENT_LINKS_CONFIG_MUTATION,
+                    // Sent as given: an absent key keeps the stored value, and the engine names
+                    // anything it refuses.
+                    variables: { input },
+                }, options);
+                return data.updatePaymentLinksConfig;
+            },
+        },
+        async testConnection(options) {
+            const data = await transport.graphql({ api: 'admin', query: TEST_PAYMENT_LINKS_CONNECTION_MUTATION }, options);
+            return data.testPaymentLinksConnection;
+        },
+        async registerWebhook(options) {
+            const data = await transport.graphql({ api: 'admin', query: REGISTER_PAYMENT_LINKS_WEBHOOK_MUTATION }, options);
+            return data.registerPaymentLinksWebhook;
+        },
+        async createSandboxAppToken(options) {
+            const data = await transport.graphql({ api: 'admin', query: CREATE_PAYMENT_LINKS_SANDBOX_APP_TOKEN_MUTATION }, options);
+            return data.createPaymentLinksSandboxAppToken;
+        },
+        async requests(orderId, options) {
+            const data = await transport.graphql({ api: 'admin', query: ORDER_PAYMENT_LINK_REQUESTS_QUERY, variables: { orderId } }, options);
+            return data.orderPaymentLinkRequests;
+        },
+    };
+}

package/dist/payments/provider-keys.d.ts

@@ -0,0 +1,150 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+import type { PaymentMethodCredentialPath } from './methods.js';
+/** Which provider a payment method's key is for, by its handler. */
+export type ProviderKeyProvider = 'mollie' | 'stripe' | 'other';
+/**
+ * One payment method's provider key, as the Mollie and Stripe cards show it. A secret is never
+ * answered, to anyone: only whether it is set and the API key's last four characters.
+ */
+export interface PaymentProviderKey {
+    paymentMethodId: string;
+    /** The payment method's code: what {@link ProviderKeysModule.set} and `test` take. */
+    paymentMethodCode: string;
+    /** `mollie` or `stripe` by the method's handler; `other` for every other handler. */
+    provider: ProviderKeyProvider;
+    enabled: boolean;
+    hasApiKey: boolean;
+    /** The API key masked to its last four (`test_••••3a9f`), or null when none is set. */
+    maskedApiKey: string | null;
+    /** Stripe's webhook signing secret is set (never answered itself). Always false for Mollie. */
+    hasWebhookSecret: boolean;
+    /** Where the provider sends its webhooks for this method; `''` for any other handler. */
+    webhookUrl: string;
+    /** Mollie's return URL; null when the method has none. */
+    redirectUrl: string | null;
+    /**
+     * What the method takes payments with: its own key (`api_key`, every non-Mollie method) or
+     * the store's Mollie Connect account (`connect`). While it is `connect` the key here is kept
+     * but does not take payments, and {@link ProviderKeysModule.test} tests the key, not the
+     * Connect account. Changed only with `payments.methods.setCredentialPath`.
+     */
+    credentialPath: PaymentMethodCredentialPath;
+}
+/** What the provider's own API said of the stored key. */
+export interface ProviderKeyTest {
+    /** The provider accepted the key. */
+    ok: boolean;
+    /** `Connected`, or why not, in the provider's or the engine's words. */
+    message: string;
+    /** Mollie only, when `ok`: the checkout methods its account offers. Null otherwise. */
+    methods: string[] | null;
+}
+/**
+ * A change to one method's key. What is left out, or sent blank, keeps what the method has:
+ * this door never clears a key.
+ */
+export interface SetProviderKeyInput {
+    paymentMethodCode: string;
+    /** A new API key (Mollie `test_…`/`live_…`, Stripe `sk_…`). */
+    apiKey?: string;
+    /** A new Stripe webhook signing secret (`whsec_…`); ignored for any other provider. */
+    webhookSecret?: string;
+    redirectUrl?: string;
+    enabled?: boolean;
+}
+/**
+ * The store's own Mollie and Stripe API keys: the LEGACY credential path, one key per payment
+ * method (headless spec §8.9). Deprecated in the schema and supported in the code: a store moves
+ * to an account onboarded through the platform (`payments.providers.startOnboarding`) when it
+ * chooses to, and `payments.providers.readiness` says which path it is on.
+ *
+ * Scoped to the store the client is on. No key is ever answered: only whether it is set and a
+ * masked preview. A method whose handler belongs to a plugin the store does not hold (Mollie,
+ * Stripe) is refused `PLUGIN_ACCESS_DENIED` (`PermissionDeniedError`, 403) by every call that
+ * names it; `list` is not.
+ */
+export interface ProviderKeysModule {
+    /**
+     * Every payment method of the store with its provider key state, Mollie, Stripe and any other
+     * handler alike, in one complete page. Needs `ReadPaymentMethod`.
+     *
+     * @deprecated legacy per-channel keys; use provider onboarding
+     * (`payments.providers.startOnboarding`).
+     * @effect read
+     * @permission ReadPaymentMethod
+     */
+    list(options?: Call): Promise<Page<PaymentProviderKey>>;
+    /**
+     * One method's key state by the method's code, or null when the store has no method with that
+     * code. Needs `ReadPaymentMethod`.
+     *
+     * @deprecated legacy per-channel keys; use provider onboarding
+     * (`payments.providers.startOnboarding`).
+     * @effect read
+     * @permission ReadPaymentMethod
+     */
+    get(paymentMethodCode: string, options?: Call): Promise<PaymentProviderKey | null>;
+    /**
+     * Give the store a Mollie or Stripe payment method to put a key on: disabled, with no key,
+     * Mollie's return URL defaulted to its webhook URL. The method is the store's alone. When the
+     * store already has a method for that provider, that one is answered and nothing is written,
+     * so a repeat is safe. Needs `UpdatePaymentMethod`.
+     *
+     * Refused, with nothing written: `USER_INPUT_ERROR` (`ValidationError`, 400) for a provider
+     * other than `mollie` or `stripe`; `PLUGIN_ACCESS_DENIED` (403) when the store does not hold
+     * that provider's plugin; `ORGANIZATION_WORKSPACE_NOT_A_STORE` (`BusinessRuleError`, 422):
+     * an organization's workspace takes no payments.
+     *
+     * @effect write
+     * @permission UpdatePaymentMethod
+     */
+    create(provider: 'mollie' | 'stripe', options?: Call): Promise<PaymentProviderKey>;
+    /**
+     * Change one method's key, webhook secret, return URL or `enabled`, and answer its key state
+     * as {@link get} reads it. What is left out or blank keeps what is stored (to CLEAR a key, use
+     * `payments.methods.update` with the argument empty). Needs `UpdatePaymentMethod` here, and on
+     * every other store holding the method: a change reaches each of them.
+     *
+     * Refused, with nothing saved:
+     *
+     * - `SECRET_ARG_MASK_INVALID` (`ValidationError`, 400): a key was sent in its masked form and
+     *   it is not the stored key's mask (the key changed since it was read). Read it again, or
+     *   send the full key.
+     * - `APP_SECRET_ARG_NOT_ALLOWED` (`PermissionDeniedError`, 403): an app installation may not
+     *   set or replace a key or webhook secret.
+     * - `LIVE_CONNECTION_REFUSED` (`BusinessRuleError`, 422): a store that is not live (a sandbox)
+     *   may hold only a TEST key (`test_…`, `sk_test_…`). Judged on the key the method would hold,
+     *   so enabling a sandbox method that already holds a live key is refused too.
+     * - `SHARED_PAYMENT_METHOD_NOT_ALLOWED` (`PermissionDeniedError`, 403): another store holds the
+     *   method and the caller may not change it there.
+     * - `USER_INPUT_ERROR` (`ValidationError`, 400): the store has no method with that code.
+     * - `PLUGIN_ACCESS_DENIED` (403), see the module.
+     *
+     * @deprecated legacy per-channel keys; use provider onboarding
+     * (`payments.providers.startOnboarding`).
+     * @effect write
+     * @permission UpdatePaymentMethod
+     */
+    set(input: SetProviderKeyInput, options?: Call): Promise<PaymentProviderKey>;
+    /**
+     * Ask the provider whether the method's stored key works (Mollie: its checkout methods;
+     * Stripe: the account balance). Changes nothing, here or at the provider.
+     *
+     * Never throws for the provider's answer: a rejected key, an unreachable provider, a method
+     * with no key or a handler that cannot be tested all answer `{ ok: false, message }`. It
+     * throws only when the call itself is refused: `USER_INPUT_ERROR` (`ValidationError`, 400)
+     * for a code the store has no method for, `PLUGIN_ACCESS_DENIED` (403), and `FORBIDDEN` (403)
+     * without `UpdatePaymentMethod`, which it needs because it uses the stored key.
+     *
+     * @effect read
+     * @permission UpdatePaymentMethod
+     */
+    test(paymentMethodCode: string, options?: Call): Promise<ProviderKeyTest>;
+}
+export declare const PAYMENT_PROVIDER_KEYS_QUERY = "\n  query PaymentProviderKeys {\n    paymentProviderConnections { \n  paymentMethodId\n  paymentMethodCode\n  provider\n  enabled\n  hasApiKey\n  maskedApiKey\n  hasWebhookSecret\n  webhookUrl\n  redirectUrl\n  credentialPath\n }\n  }\n";
+export declare const PAYMENT_PROVIDER_KEY_QUERY = "\n  query PaymentProviderKey($paymentMethodCode: String!) {\n    paymentProviderConnection(paymentMethodCode: $paymentMethodCode) { \n  paymentMethodId\n  paymentMethodCode\n  provider\n  enabled\n  hasApiKey\n  maskedApiKey\n  hasWebhookSecret\n  webhookUrl\n  redirectUrl\n  credentialPath\n }\n  }\n";
+export declare const CREATE_PAYMENT_PROVIDER_MUTATION = "\n  mutation CreatePaymentProviderKey($provider: String!) {\n    createPaymentProvider(provider: $provider) { \n  paymentMethodId\n  paymentMethodCode\n  provider\n  enabled\n  hasApiKey\n  maskedApiKey\n  hasWebhookSecret\n  webhookUrl\n  redirectUrl\n  credentialPath\n }\n  }\n";
+export declare const SET_PAYMENT_PROVIDER_CREDENTIALS_MUTATION = "\n  mutation SetPaymentProviderKey($input: SetPaymentProviderCredentialsInput!) {\n    setPaymentProviderCredentials(input: $input) { \n  paymentMethodId\n  paymentMethodCode\n  provider\n  enabled\n  hasApiKey\n  maskedApiKey\n  hasWebhookSecret\n  webhookUrl\n  redirectUrl\n  credentialPath\n }\n  }\n";
+export declare const TEST_PAYMENT_PROVIDER_CONNECTION_MUTATION = "\n  mutation TestPaymentProviderKey($paymentMethodCode: String!) {\n    testPaymentProviderConnection(paymentMethodCode: $paymentMethodCode) {\n      ok\n      message\n      methods\n    }\n  }\n";
+export declare function createProviderKeysModule(transport: Transport): ProviderKeysModule;

package/dist/payments/provider-keys.js

@@ -0,0 +1,118 @@
+import { createPage, ValidationError } from '@sixtyninecommerce/core';
+import { fieldOf } from '../catalog/types.js';
+const KEY_FIELDS = /* GraphQL */ `
+  paymentMethodId
+  paymentMethodCode
+  provider
+  enabled
+  hasApiKey
+  maskedApiKey
+  hasWebhookSecret
+  webhookUrl
+  redirectUrl
+  credentialPath
+`;
+export const PAYMENT_PROVIDER_KEYS_QUERY = /* GraphQL */ `
+  query PaymentProviderKeys {
+    paymentProviderConnections { ${KEY_FIELDS} }
+  }
+`;
+export const PAYMENT_PROVIDER_KEY_QUERY = /* GraphQL */ `
+  query PaymentProviderKey($paymentMethodCode: String!) {
+    paymentProviderConnection(paymentMethodCode: $paymentMethodCode) { ${KEY_FIELDS} }
+  }
+`;
+export const CREATE_PAYMENT_PROVIDER_MUTATION = /* GraphQL */ `
+  mutation CreatePaymentProviderKey($provider: String!) {
+    createPaymentProvider(provider: $provider) { ${KEY_FIELDS} }
+  }
+`;
+export const SET_PAYMENT_PROVIDER_CREDENTIALS_MUTATION = /* GraphQL */ `
+  mutation SetPaymentProviderKey($input: SetPaymentProviderCredentialsInput!) {
+    setPaymentProviderCredentials(input: $input) { ${KEY_FIELDS} }
+  }
+`;
+export const TEST_PAYMENT_PROVIDER_CONNECTION_MUTATION = /* GraphQL */ `
+  mutation TestPaymentProviderKey($paymentMethodCode: String!) {
+    testPaymentProviderConnection(paymentMethodCode: $paymentMethodCode) {
+      ok
+      message
+      methods
+    }
+  }
+`;
+const invalidInput = (message) => new ValidationError({
+    code: 'INVALID_PROVIDER_KEY_INPUT',
+    message,
+    status: 400,
+    service: 'vendure',
+});
+const requireCode = (value) => {
+    if (typeof value !== 'string' || value === '') {
+        throw invalidInput('paymentMethodCode must be the code of a payment method.');
+    }
+    return value;
+};
+const toKey = (wire) => ({
+    paymentMethodId: wire.paymentMethodId,
+    paymentMethodCode: wire.paymentMethodCode,
+    provider: wire.provider === 'mollie' || wire.provider === 'stripe' ? wire.provider : 'other',
+    enabled: wire.enabled,
+    hasApiKey: wire.hasApiKey,
+    maskedApiKey: wire.maskedApiKey ?? null,
+    hasWebhookSecret: wire.hasWebhookSecret,
+    webhookUrl: wire.webhookUrl,
+    redirectUrl: wire.redirectUrl ?? null,
+    credentialPath: wire.credentialPath === 'connect' ? 'connect' : 'api_key',
+});
+/** The input as the engine takes it; a field of the wrong type never leaves. */
+function setInput(input) {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw invalidInput('A key change must be an object naming the payment method.');
+    }
+    const value = input;
+    const out = { paymentMethodCode: requireCode(value.paymentMethodCode) };
+    for (const name of ['apiKey', 'webhookSecret', 'redirectUrl']) {
+        const field = value[name];
+        if (field === undefined)
+            continue;
+        if (typeof field !== 'string')
+            throw invalidInput(`${name} must be a string.`);
+        out[name] = field;
+    }
+    if (value.enabled !== undefined) {
+        if (typeof value.enabled !== 'boolean')
+            throw invalidInput('enabled must be true or false.');
+        out.enabled = value.enabled;
+    }
+    return out;
+}
+export function createProviderKeysModule(transport) {
+    return {
+        async list(options) {
+            const items = (await fieldOf(transport, PAYMENT_PROVIDER_KEYS_QUERY, 'paymentProviderConnections', {}, options)).map(toKey);
+            // The engine answers every method at once: one complete page.
+            return createPage(items, { nextCursor: null, hasNext: false, total: items.length }, () => {
+                throw new Error('paymentProviderConnections returns a complete list; there is no next page');
+            });
+        },
+        async get(paymentMethodCode, options) {
+            const key = await fieldOf(transport, PAYMENT_PROVIDER_KEY_QUERY, 'paymentProviderConnection', { paymentMethodCode: requireCode(paymentMethodCode) }, options);
+            return key ? toKey(key) : null;
+        },
+        async create(provider, options) {
+            // Typed for TypeScript callers; checked for JavaScript ones and MCP tool arguments.
+            if (typeof provider !== 'string' || provider === '') {
+                throw invalidInput('provider must be `mollie` or `stripe`.');
+            }
+            return toKey(await fieldOf(transport, CREATE_PAYMENT_PROVIDER_MUTATION, 'createPaymentProvider', { provider }, options));
+        },
+        async set(input, options) {
+            return toKey(await fieldOf(transport, SET_PAYMENT_PROVIDER_CREDENTIALS_MUTATION, 'setPaymentProviderCredentials', { input: setInput(input) }, options));
+        },
+        async test(paymentMethodCode, options) {
+            const result = await fieldOf(transport, TEST_PAYMENT_PROVIDER_CONNECTION_MUTATION, 'testPaymentProviderConnection', { paymentMethodCode: requireCode(paymentMethodCode) }, options);
+            return { ok: result.ok, message: result.message, methods: result.methods ?? null };
+        },
+    };
+}