@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/payments/methods.js

@@ -0,0 +1,363 @@
+import { ConflictError, createPage, ValidationError, } from '@sixtyninecommerce/core';
+import { assertDeleted, fieldOf, vendureListPage, } from '../catalog/types.js';
+import { createMollieMethodsModule } from './mollie-methods.js';
+import { createProviderKeysModule } from './provider-keys.js';
+/** A store has a handful; one page holds them. */
+const DEFAULT_PAGE_SIZE = 100;
+const OPERATION_FIELDS = /* GraphQL */ `
+  code
+  args {
+    name
+    value
+  }
+`;
+/** One selection for the list and the single read, so both answer the same {@link PaymentMethod}. */
+const METHOD_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  updatedAt
+  code
+  name
+  description
+  enabled
+  handler { ${OPERATION_FIELDS} }
+  checker { ${OPERATION_FIELDS} }
+  translations {
+    id
+    languageCode
+    name
+    description
+  }
+  customFields {
+    isNetTermsCredit
+    netTermsStaffAnyCustomer
+    enabledInStorefront
+  }
+`;
+export const PAYMENT_METHODS_QUERY = /* GraphQL */ `
+  query StorePaymentMethods($options: PaymentMethodListOptions) {
+    paymentMethods(options: $options) {
+      items { ${METHOD_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const PAYMENT_METHOD_QUERY = /* GraphQL */ `
+  query StorePaymentMethod($id: ID!) {
+    paymentMethod(id: $id) { ${METHOD_FIELDS} }
+  }
+`;
+const DEFINITION_FIELDS = /* GraphQL */ `
+  code
+  description
+  args {
+    name
+    type
+    list
+    required
+    defaultValue
+    label
+    description
+    ui
+  }
+`;
+export const PAYMENT_METHOD_HANDLERS_QUERY = /* GraphQL */ `
+  query PaymentMethodHandlers {
+    paymentMethodHandlers { ${DEFINITION_FIELDS} }
+  }
+`;
+export const PAYMENT_METHOD_CHECKERS_QUERY = /* GraphQL */ `
+  query PaymentMethodEligibilityCheckers {
+    paymentMethodEligibilityCheckers { ${DEFINITION_FIELDS} }
+  }
+`;
+export const PAYMENT_METHOD_CREDENTIAL_PATH_QUERY = /* GraphQL */ `
+  query PaymentMethodCredentialPath($code: String!) {
+    paymentMethods(options: { filter: { code: { eq: $code } }, take: 1 }) {
+      items {
+        code
+        customFields {
+          mollieCredentialPath
+        }
+      }
+    }
+  }
+`;
+export const SET_PAYMENT_METHOD_CREDENTIAL_PATH_MUTATION = /* GraphQL */ `
+  mutation SetPaymentMethodCredentialPath(
+    $paymentMethodCode: String!
+    $path: PaymentMethodCredentialPath!
+  ) {
+    setPaymentMethodCredentialPath(paymentMethodCode: $paymentMethodCode, path: $path) {
+      paymentMethodCode
+      credentialPath
+    }
+  }
+`;
+export const CREATE_PAYMENT_METHOD_MUTATION = /* GraphQL */ `
+  mutation CreateStorePaymentMethod($input: CreatePaymentMethodInput!) {
+    createPaymentMethod(input: $input) { ${METHOD_FIELDS} }
+  }
+`;
+export const UPDATE_PAYMENT_METHOD_MUTATION = /* GraphQL */ `
+  mutation UpdateStorePaymentMethod($input: UpdatePaymentMethodInput!) {
+    updatePaymentMethod(input: $input) { ${METHOD_FIELDS} }
+  }
+`;
+// `force: false`, written into the document: in the default channel `true` deletes a method
+// other stores still hold, and no caller of this SDK may ask for that.
+export const DELETE_PAYMENT_METHOD_MUTATION = /* GraphQL */ `
+  mutation DeleteStorePaymentMethod($id: ID!) {
+    deletePaymentMethod(id: $id, force: false) {
+      result
+      message
+    }
+  }
+`;
+export const DELETE_PAYMENT_METHODS_MUTATION = /* GraphQL */ `
+  mutation DeleteStorePaymentMethods($ids: [ID!]!) {
+    deletePaymentMethods(ids: $ids, force: false) {
+      result
+      message
+    }
+  }
+`;
+export const ASSIGN_PAYMENT_METHODS_TO_CHANNEL_MUTATION = /* GraphQL */ `
+  mutation AssignPaymentMethodsToStore($input: AssignPaymentMethodsToChannelInput!) {
+    assignPaymentMethodsToChannel(input: $input) { ${METHOD_FIELDS} }
+  }
+`;
+export const REMOVE_PAYMENT_METHODS_FROM_CHANNEL_MUTATION = /* GraphQL */ `
+  mutation RemovePaymentMethodsFromStore($input: RemovePaymentMethodsFromChannelInput!) {
+    removePaymentMethodsFromChannel(input: $input) { ${METHOD_FIELDS} }
+  }
+`;
+const invalidInput = (message) => new ValidationError({
+    code: 'INVALID_PAYMENT_METHOD_INPUT',
+    message,
+    status: 400,
+    service: 'vendure',
+});
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isIdList = (value) => Array.isArray(value) && value.every((id) => typeof id === 'string' && id !== '');
+const FLAGS = ['isNetTermsCredit', 'netTermsStaffAnyCustomer', 'enabledInStorefront'];
+/** A handler or checker as the engine takes it, checked here so a wrong shape never leaves. */
+function operationInput(value, what) {
+    if (!isObject(value) || typeof value.code !== 'string' || value.code === '') {
+        throw invalidInput(`${what} needs a code.`);
+    }
+    const args = value.arguments;
+    if (!Array.isArray(args) ||
+        !args.every((arg) => isObject(arg) && typeof arg.name === 'string' && typeof arg.value === 'string')) {
+        throw invalidInput(`${what}.arguments must be a list of { name, value } strings (a list or a boolean JSON-encoded).`);
+    }
+    return {
+        code: value.code,
+        arguments: args.map((arg) => ({ name: String(arg.name), value: String(arg.value) })),
+    };
+}
+function translationsInput(value) {
+    if (!Array.isArray(value) ||
+        !value.every((row) => isObject(row) &&
+            typeof row.languageCode === 'string' &&
+            row.languageCode !== '' &&
+            typeof row.name === 'string' &&
+            (row.description === undefined || typeof row.description === 'string'))) {
+        throw invalidInput('translations must be a list of { languageCode, name, description? } with strings.');
+    }
+    return value.map((row) => ({
+        languageCode: String(row.languageCode),
+        name: String(row.name),
+        description: typeof row.description === 'string' ? row.description : '',
+    }));
+}
+/**
+ * The fields both writes share, in the engine's shape: the three flags under `customFields`,
+ * the checker kept as null (which an update reads as "take it away").
+ */
+function sharedInput(input) {
+    const out = {};
+    if (input.code !== undefined) {
+        if (typeof input.code !== 'string')
+            throw invalidInput('code must be a string.');
+        out.code = input.code;
+    }
+    if (input.enabled !== undefined) {
+        if (typeof input.enabled !== 'boolean')
+            throw invalidInput('enabled must be true or false.');
+        out.enabled = input.enabled;
+    }
+    if (input.handler !== undefined)
+        out.handler = operationInput(input.handler, 'handler');
+    if (input.checker === null)
+        out.checker = null;
+    else if (input.checker !== undefined)
+        out.checker = operationInput(input.checker, 'checker');
+    if (input.translations !== undefined)
+        out.translations = translationsInput(input.translations);
+    const customFields = {};
+    for (const flag of FLAGS) {
+        const value = input[flag];
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'boolean')
+            throw invalidInput(`${flag} must be true or false.`);
+        customFields[flag] = value;
+    }
+    if (Object.keys(customFields).length > 0)
+        out.customFields = customFields;
+    return out;
+}
+function assignmentInput(ids, channelId) {
+    if (!isIdList(ids))
+        throw invalidInput('ids must be a list of payment method ids.');
+    if (typeof channelId !== 'string' || channelId === '') {
+        throw invalidInput("channelId must be the receiving store's channel id.");
+    }
+    return [...ids];
+}
+const asPath = (value) => value === 'connect' ? 'connect' : 'api_key';
+const toMethod = (method) => ({
+    id: method.id,
+    code: method.code,
+    name: method.name,
+    description: method.description,
+    enabled: method.enabled,
+    handlerCode: method.handler.code,
+    // As answered: the engine has already masked each secret argument for this caller.
+    handler: method.handler,
+    checker: method.checker ?? null,
+    translations: method.translations,
+    // A flag the engine did not answer reads as its column's default: the two net-terms flags
+    // off, the storefront flag on.
+    isNetTermsCredit: method.customFields?.isNetTermsCredit === true,
+    netTermsStaffAnyCustomer: method.customFields?.netTermsStaffAnyCustomer === true,
+    enabledInStorefront: method.customFields?.enabledInStorefront !== false,
+    createdAt: method.createdAt,
+    updatedAt: method.updatedAt,
+});
+/** A complete array behind the SDK's page shape: the engine lists every definition at once. */
+function wholeList(items, what) {
+    return createPage(items, { nextCursor: null, hasNext: false, total: items.length }, () => {
+        // Unreachable while `hasNext` is false: `Page.next()` short-circuits.
+        throw new Error(`${what} returns a complete list; there is no next page`);
+    });
+}
+export function createPaymentMethodsModule(transport) {
+    return {
+        providerKeys: createProviderKeysModule(transport),
+        mollie: createMollieMethodsModule(transport),
+        list(options) {
+            return vendureListPage(transport, PAYMENT_METHODS_QUERY, 'paymentMethods', (skip, take) => ({ options: { skip, take } }), { ...options, limit: options?.limit ?? DEFAULT_PAGE_SIZE }, toMethod);
+        },
+        async get(id, options) {
+            const method = await fieldOf(transport, PAYMENT_METHOD_QUERY, 'paymentMethod', { id }, options);
+            return method ? toMethod(method) : null;
+        },
+        async handlers(options) {
+            return wholeList(await fieldOf(transport, PAYMENT_METHOD_HANDLERS_QUERY, 'paymentMethodHandlers', {}, options), 'paymentMethodHandlers');
+        },
+        async checkers(options) {
+            return wholeList(await fieldOf(transport, PAYMENT_METHOD_CHECKERS_QUERY, 'paymentMethodEligibilityCheckers', {}, options), 'paymentMethodEligibilityCheckers');
+        },
+        async credentialPath(paymentMethodCode, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: PAYMENT_METHOD_CREDENTIAL_PATH_QUERY,
+                variables: { code: paymentMethodCode },
+            }, options);
+            // `eq` is not guaranteed case-sensitive on every driver: the code is matched here too.
+            const method = data.paymentMethods.items.find((item) => item.code === paymentMethodCode);
+            return method ? asPath(method.customFields?.mollieCredentialPath) : null;
+        },
+        async setCredentialPath(paymentMethodCode, path, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_PAYMENT_METHOD_CREDENTIAL_PATH_MUTATION,
+                variables: { paymentMethodCode, path },
+            }, options);
+            return {
+                paymentMethodCode: data.setPaymentMethodCredentialPath.paymentMethodCode,
+                credentialPath: asPath(data.setPaymentMethodCredentialPath.credentialPath),
+            };
+        },
+        async create(input, options) {
+            if (!isObject(input))
+                throw invalidInput('A new payment method must be an object.');
+            if (typeof input.code !== 'string')
+                throw invalidInput('A payment method needs a code.');
+            if (typeof input.enabled !== 'boolean') {
+                throw invalidInput('A new payment method says whether it is enabled.');
+            }
+            if (input.handler === undefined)
+                throw invalidInput('A payment method needs a handler.');
+            if (input.translations === undefined) {
+                throw invalidInput('A payment method needs its name in at least one language.');
+            }
+            const wireInput = sharedInput(input);
+            // Core's create takes no null checker: "none" is leaving it out.
+            if (wireInput.checker === null)
+                delete wireInput.checker;
+            return toMethod(await fieldOf(transport, CREATE_PAYMENT_METHOD_MUTATION, 'createPaymentMethod', { input: wireInput }, options));
+        },
+        async update(id, patch, options) {
+            if (typeof id !== 'string' || id === '')
+                throw invalidInput('id must be a payment method id.');
+            if (!isObject(patch))
+                throw invalidInput('The change to a payment method must be an object.');
+            return toMethod(await fieldOf(transport, UPDATE_PAYMENT_METHOD_MUTATION, 'updatePaymentMethod', { input: { id, ...sharedInput(patch) } }, options));
+        },
+        async delete(id, options) {
+            if (typeof id !== 'string' || id === '')
+                throw invalidInput('id must be a payment method id.');
+            assertDeleted('PAYMENT_METHOD_NOT_DELETED', [
+                await fieldOf(transport, DELETE_PAYMENT_METHOD_MUTATION, 'deletePaymentMethod', { id }, options),
+            ]);
+        },
+        async deleteMany(ids, options) {
+            if (!isIdList(ids))
+                throw invalidInput('ids must be a list of payment method ids.');
+            if (ids.length === 0)
+                return;
+            const responses = await fieldOf(transport, DELETE_PAYMENT_METHODS_MUTATION, 'deletePaymentMethods', { ids: [...ids] }, options);
+            // One answer per id, in the order sent. A missing answer is not a removal.
+            const kept = ids.flatMap((id, index) => {
+                const response = Array.isArray(responses) ? responses[index] : undefined;
+                return response?.result === 'DELETED'
+                    ? []
+                    : [{ id, index, reason: response?.message ?? 'The server gave no reason.' }];
+            });
+            if (kept.length === 0)
+                return;
+            // Answered at HTTP 200, so the transport never throws for it: the ids not named here WERE
+            // removed.
+            throw new ConflictError({
+                code: 'PAYMENT_METHOD_NOT_DELETED',
+                message: kept.length === ids.length
+                    ? `No payment method was removed: ${kept[0]?.reason ?? ''}`
+                    : `${String(kept.length)} of ${String(ids.length)} payment methods were not removed (the others were): ${kept[0]?.reason ?? ''}`,
+                status: 409,
+                service: 'vendure',
+                details: kept.map(({ id, index, reason }) => ({
+                    field: `ids.${String(index)}`,
+                    code: 'PAYMENT_METHOD_NOT_DELETED',
+                    message: `${id}: ${reason}`,
+                })),
+            });
+        },
+        async assignToStores(ids, channelId, options) {
+            const paymentMethodIds = assignmentInput(ids, channelId);
+            if (paymentMethodIds.length === 0)
+                return [];
+            const methods = await fieldOf(transport, ASSIGN_PAYMENT_METHODS_TO_CHANNEL_MUTATION, 'assignPaymentMethodsToChannel', { input: { paymentMethodIds, channelId } }, options);
+            return methods.map(toMethod);
+        },
+        async removeFromStores(ids, channelId, options) {
+            const paymentMethodIds = assignmentInput(ids, channelId);
+            if (paymentMethodIds.length === 0)
+                return [];
+            const methods = await fieldOf(transport, REMOVE_PAYMENT_METHODS_FROM_CHANNEL_MUTATION, 'removePaymentMethodsFromChannel', { input: { paymentMethodIds, channelId } }, options);
+            return methods.map(toMethod);
+        },
+    };
+}

package/dist/payments/mollie-methods.d.ts

@@ -0,0 +1,159 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** Why Mollie's own answer is missing: the method has nothing to ask with, or Mollie refused. */
+export type MollieProbeErrorKind = 'no_key' | 'auth' | 'network' | 'provider';
+/** What went wrong asking Mollie, in the engine's classification. */
+export interface MollieProbeError {
+    /**
+     * `no_key`: nothing to ask with (no such method in the store, not a Mollie method, no key, or
+     * a Connect-path method whose store has no Mollie account connected); `auth`: Mollie refused
+     * the key or the Connect grant; `network`: Mollie did not answer; `provider`: Mollie answered
+     * with an error. An unknown kind reads `provider`.
+     */
+    kind: MollieProbeErrorKind;
+    /** In the engine's or Mollie's words. */
+    message: string;
+    /** Mollie's real HTTP status when it answered; null otherwise. */
+    statusCode: number | null;
+}
+/** One checkout method of the Mollie account, with the store's choice to hide it. */
+export interface MollieMethod {
+    /** Mollie's method id: `ideal`, `creditcard`, `klarnapaylater`, … */
+    id: string;
+    description: string | null;
+    /** Mollie's icon for it (SVG preferred); null when Mollie gave none. */
+    imageUrl: string | null;
+    /** The store hides it at checkout (`setMethods`). */
+    hidden: boolean;
+    /**
+     * Mollie's activation status: `activated`, `pending-boarding`, `pending-review`,
+     * `pending-external` or `rejected`; null when Mollie gave none.
+     */
+    status: string | null;
+    /** Usable now: `activated`, or no status given. */
+    available: boolean;
+}
+/** The method list of one Mollie payment method, in the store's checkout order. */
+export interface MollieMethodList {
+    /**
+     * Mollie's one-off (checkout) methods merged with the saved order, hidden ones included.
+     * Mandate-only methods (SEPA `directdebit`) are never here: see `diagnose`.
+     */
+    methods: MollieMethod[];
+    /**
+     * Why Mollie's list is missing, or null. An empty `methods` with a null `error` means Mollie
+     * answered and offers no method on this profile.
+     */
+    error: MollieProbeError | null;
+}
+/** The checkout order and the hidden methods, each as Mollie's method ids. */
+export interface SetMollieMethodsInput {
+    /** Every method id, in the order the checkout shows them. */
+    order: string[];
+    /** The method ids the checkout hides. */
+    hidden: string[];
+}
+/** One method of the account across Mollie's three payment sequences. */
+export interface MollieDiagnosisMethod {
+    id: string;
+    description: string | null;
+    /** Mollie's activation status, when its list of every method gave one. */
+    status: string | null;
+    /** Offered for a regular checkout payment. */
+    oneoff: boolean;
+    /** Offered as the first payment of a recurring sequence (it creates a mandate). */
+    first: boolean;
+    /** Offered for charging an existing mandate. */
+    recurring: boolean;
+}
+/** SEPA Direct Debit (`directdebit`) as each probe saw it. */
+export interface MollieDirectDebitDiagnosis {
+    availableOneoff: boolean;
+    availableFirst: boolean;
+    availableRecurring: boolean;
+    status: string | null;
+    /** What Mollie answered for `directdebit` itself: `ok`, `forbidden`, `not_found` or `error`. */
+    getProbe: string;
+}
+/**
+ * The headline answer, about SEPA Direct Debit at checkout:
+ * `CHECKOUT_TILE_AVAILABLE`, `CHECKOUT_TILE_PENDING_ACTIVATION`, `MANDATE_ONLY`,
+ * `NOT_ON_ACCOUNT`, `INDETERMINATE`, `REJECTED`, `UNKNOWN_KEY_ERROR` (every probe refused, or
+ * nothing to probe with) or `UNREACHABLE`. A verdict the engine adds later is passed through.
+ */
+export type MollieDiagnosisVerdict = 'CHECKOUT_TILE_AVAILABLE' | 'CHECKOUT_TILE_PENDING_ACTIVATION' | 'MANDATE_ONLY' | 'NOT_ON_ACCOUNT' | 'INDETERMINATE' | 'REJECTED' | 'UNKNOWN_KEY_ERROR' | 'UNREACHABLE';
+/** What Mollie's account offers for each payment sequence, and the verdict drawn from it. */
+export interface MollieDiagnosis {
+    /** Every probe succeeded. */
+    ok: boolean;
+    /** From the key's prefix only (`test_`, `live_`); `unknown` without a key. */
+    keyMode: 'test' | 'live' | 'unknown';
+    /** The first probe's failure, or null. */
+    error: MollieProbeError | null;
+    methods: MollieDiagnosisMethod[];
+    directDebit: MollieDirectDebitDiagnosis;
+    verdict: MollieDiagnosisVerdict;
+    /** When the probes ran (ISO 8601, UTC). */
+    probedAt: string;
+}
+/**
+ * The checkout methods a Mollie payment method offers, their order and visibility, and a
+ * diagnosis of the Mollie account (headless spec §9.2 `payments`). Scoped to the store the
+ * client is on. Configuration only: nothing here moves money.
+ *
+ * Every call is refused `PLUGIN_ACCESS_DENIED` (`PermissionDeniedError`, 403) for a store that
+ * does not hold the Mollie plugin.
+ */
+export interface MollieMethodsModule {
+    /**
+     * Mollie's checkout methods for one payment method, merged with the store's saved order and
+     * hidden list. Asked with the method's own API key, or through the store's Mollie Connect
+     * account when the method pays through it (`credentialPath: 'connect'`). Goes to Mollie on
+     * every call. Needs `ReadPaymentMethod`.
+     *
+     * Never throws for Mollie's answer: a refused key or grant, Mollie not answering, a method
+     * with nothing to ask with, a code the store has no method for and a method that is not
+     * Mollie's all answer an empty or saved-only `methods` with `error` saying why.
+     *
+     * @effect read
+     * @permission ReadPaymentMethod
+     */
+    methods(paymentMethodCode: string, options?: Call): Promise<MollieMethodList>;
+    /**
+     * Save the checkout order and the hidden methods of one payment method, and answer the list
+     * as {@link methods} reads it (so it asks Mollie again). The lists are stored as sent: an id
+     * Mollie does not offer is kept, and a method Mollie offers that `order` leaves out is shown
+     * after the ordered ones. Needs `UpdatePaymentMethod`.
+     *
+     * Refused, with nothing saved:
+     *
+     * - `USER_INPUT_ERROR` (`ValidationError`, 400): the store has no method with that code.
+     * - `SHARED_PAYMENT_METHOD_NOT_ALLOWED` (`PermissionDeniedError`, 403): another store holds
+     *   the method and the caller may not change it there.
+     * - `INVALID_MOLLIE_METHODS_INPUT` (`ValidationError`, 400), before sending: `order` or
+     *   `hidden` is not a list of strings.
+     *
+     * @effect write
+     * @permission UpdatePaymentMethod
+     */
+    setMethods(paymentMethodCode: string, input: SetMollieMethodsInput, options?: Call): Promise<MollieMethodList>;
+    /**
+     * Ask Mollie, with the method's own API key, which methods it offers for each payment
+     * sequence (one-off, first, recurring), and draw a verdict on SEPA Direct Debit. Five calls
+     * to Mollie; changes nothing, here or at Mollie. A method paying through Mollie Connect is
+     * still diagnosed with its key: without one the answer is `UNKNOWN_KEY_ERROR`.
+     *
+     * Never throws for Mollie's answer (it is in `error` and `verdict`). It throws only when the
+     * call is refused: `USER_INPUT_ERROR` (`ValidationError`, 400) for a code the store has no
+     * method for, `FORBIDDEN` (`PermissionDeniedError`, 403) without `UpdatePaymentMethod`, which
+     * it needs because it uses the stored key, and `PLUGIN_ACCESS_DENIED` (403).
+     *
+     * @effect read
+     * @permission UpdatePaymentMethod
+     */
+    diagnose(paymentMethodCode: string, options?: Call): Promise<MollieDiagnosis>;
+}
+export declare const MOLLIE_METHODS_QUERY = "\n  query MollieMethodList($paymentMethodCode: String!) {\n    mollieMethods(paymentMethodCode: $paymentMethodCode) { \n  methods {\n    id\n    description\n    imageUrl\n    hidden\n    status\n    available\n  }\n  \n  error {\n    kind\n    message\n    statusCode\n  }\n\n }\n  }\n";
+export declare const SET_MOLLIE_METHODS_MUTATION = "\n  mutation SetMollieMethodList($input: SetMollieMethodsInput!) {\n    setMollieMethods(input: $input) { \n  methods {\n    id\n    description\n    imageUrl\n    hidden\n    status\n    available\n  }\n  \n  error {\n    kind\n    message\n    statusCode\n  }\n\n }\n  }\n";
+export declare const MOLLIE_DIAGNOSTICS_QUERY = "\n  query MollieDiagnosis($paymentMethodCode: String!) {\n    mollieDiagnostics(paymentMethodCode: $paymentMethodCode) {\n      ok\n      keyMode\n      \n  error {\n    kind\n    message\n    statusCode\n  }\n\n      methods {\n        id\n        description\n        status\n        oneoff\n        first\n        recurring\n      }\n      directDebit {\n        availableOneoff\n        availableFirst\n        availableRecurring\n        status\n        getProbe\n      }\n      verdict\n      probedAt\n    }\n  }\n";
+export declare function createMollieMethodsModule(transport: Transport): MollieMethodsModule;

package/dist/payments/mollie-methods.js

@@ -0,0 +1,141 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+import { fieldOf } from '../catalog/types.js';
+const PROBE_ERROR_FIELDS = /* GraphQL */ `
+  error {
+    kind
+    message
+    statusCode
+  }
+`;
+const LIST_FIELDS = /* GraphQL */ `
+  methods {
+    id
+    description
+    imageUrl
+    hidden
+    status
+    available
+  }
+  ${PROBE_ERROR_FIELDS}
+`;
+export const MOLLIE_METHODS_QUERY = /* GraphQL */ `
+  query MollieMethodList($paymentMethodCode: String!) {
+    mollieMethods(paymentMethodCode: $paymentMethodCode) { ${LIST_FIELDS} }
+  }
+`;
+export const SET_MOLLIE_METHODS_MUTATION = /* GraphQL */ `
+  mutation SetMollieMethodList($input: SetMollieMethodsInput!) {
+    setMollieMethods(input: $input) { ${LIST_FIELDS} }
+  }
+`;
+export const MOLLIE_DIAGNOSTICS_QUERY = /* GraphQL */ `
+  query MollieDiagnosis($paymentMethodCode: String!) {
+    mollieDiagnostics(paymentMethodCode: $paymentMethodCode) {
+      ok
+      keyMode
+      ${PROBE_ERROR_FIELDS}
+      methods {
+        id
+        description
+        status
+        oneoff
+        first
+        recurring
+      }
+      directDebit {
+        availableOneoff
+        availableFirst
+        availableRecurring
+        status
+        getProbe
+      }
+      verdict
+      probedAt
+    }
+  }
+`;
+const invalidInput = (message) => new ValidationError({
+    code: 'INVALID_MOLLIE_METHODS_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 requireIds = (value, name) => {
+    if (!Array.isArray(value) || value.some((id) => typeof id !== 'string')) {
+        throw invalidInput(`${name} must be a list of Mollie method ids.`);
+    }
+    return [...value];
+};
+const KINDS = ['no_key', 'auth', 'network', 'provider'];
+const toError = (wire) => wire
+    ? {
+        kind: KINDS.includes(wire.kind)
+            ? wire.kind
+            : 'provider',
+        message: wire.message,
+        statusCode: wire.statusCode ?? null,
+    }
+    : null;
+const toList = (wire) => ({
+    methods: wire.methods.map((method) => ({
+        id: method.id,
+        description: method.description ?? null,
+        imageUrl: method.imageUrl ?? null,
+        hidden: method.hidden,
+        status: method.status ?? null,
+        available: method.available,
+    })),
+    error: toError(wire.error),
+});
+const toDiagnosis = (wire) => ({
+    ok: wire.ok,
+    keyMode: wire.keyMode === 'test' || wire.keyMode === 'live' ? wire.keyMode : 'unknown',
+    error: toError(wire.error),
+    methods: wire.methods.map((method) => ({
+        id: method.id,
+        description: method.description ?? null,
+        status: method.status ?? null,
+        oneoff: method.oneoff,
+        first: method.first,
+        recurring: method.recurring,
+    })),
+    directDebit: {
+        availableOneoff: wire.directDebit.availableOneoff,
+        availableFirst: wire.directDebit.availableFirst,
+        availableRecurring: wire.directDebit.availableRecurring,
+        status: wire.directDebit.status ?? null,
+        getProbe: wire.directDebit.getProbe,
+    },
+    // Passed through: a verdict the engine adds later is still the engine's answer.
+    verdict: wire.verdict,
+    probedAt: wire.probedAt,
+});
+export function createMollieMethodsModule(transport) {
+    return {
+        async methods(paymentMethodCode, options) {
+            return toList(await fieldOf(transport, MOLLIE_METHODS_QUERY, 'mollieMethods', { paymentMethodCode: requireCode(paymentMethodCode) }, options));
+        },
+        async setMethods(paymentMethodCode, input, options) {
+            const code = requireCode(paymentMethodCode);
+            if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+                throw invalidInput('setMethods takes { order, hidden }.');
+            }
+            return toList(await fieldOf(transport, SET_MOLLIE_METHODS_MUTATION, 'setMollieMethods', {
+                input: {
+                    paymentMethodCode: code,
+                    order: requireIds(input.order, 'order'),
+                    hidden: requireIds(input.hidden, 'hidden'),
+                },
+            }, options));
+        },
+        async diagnose(paymentMethodCode, options) {
+            return toDiagnosis(await fieldOf(transport, MOLLIE_DIAGNOSTICS_QUERY, 'mollieDiagnostics', { paymentMethodCode: requireCode(paymentMethodCode) }, options));
+        },
+    };
+}