@sixtyninecommerce/admin 0.10.0 → 0.11.0

package/dist/fulfillments/payment-policy.js

@@ -0,0 +1,140 @@
+import { errorFromErrorResult, isErrorResult, ValidationError, } from '@sixtyninecommerce/core';
+// The bounds of the meta catalog's `fulfillment_payment_policy` schema
+// (`packages/shared/src/meta-catalog/settings-schemas.ts`), which the spec reads
+// back from that schema, and of the engine's write validator
+// (`validateFulfillmentPaymentPolicyValue`), which refuses the same values.
+/** The most payment method codes `exemptMethodCodes` may name. */
+export const FULFILLMENT_PAYMENT_POLICY_EXEMPT_METHODS_MAX = 50;
+/** The longest payment method code the list accepts (`PaymentMethod.code` is a varchar(255)). */
+export const FULFILLMENT_PAYMENT_POLICY_METHOD_CODE_MAX_LENGTH = 255;
+/** The policy of a store that never set one, and of a column that cannot be read: off. */
+export const DEFAULT_FULFILLMENT_PAYMENT_POLICY = Object.freeze({
+    requireFullPayment: false,
+    exemptMethodCodes: [],
+});
+const POLICY_FIELDS = /* GraphQL */ `
+  id
+  customFields {
+    fulfillmentPaymentPolicy
+  }
+`;
+export const FULFILLMENT_PAYMENT_POLICY_QUERY = /* GraphQL */ `
+  query FulfillmentPaymentPolicy {
+    activeChannel { ${POLICY_FIELDS} }
+  }
+`;
+export const SET_FULFILLMENT_PAYMENT_POLICY_MUTATION = /* GraphQL */ `
+  mutation SetFulfillmentPaymentPolicy($input: UpdateChannelInput!) {
+    updateChannel(input: $input) {
+      ... on Channel { ${POLICY_FIELDS} }
+      ... on ErrorResult { errorCode message }
+    }
+  }
+`;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** A payment method code as the engine compares it (`normalizeMethodCode`). */
+export function normalizeFulfillmentPolicyMethodCode(code) {
+    return code.trim().toLowerCase();
+}
+/** The column, read as the engine reads it: anything unreadable is OFF. */
+function readFulfillmentPaymentPolicy(raw) {
+    let parsed = raw;
+    if (typeof raw === 'string') {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            parsed = null;
+        }
+    }
+    if (!isRecord(parsed))
+        return { requireFullPayment: false, exemptMethodCodes: [] };
+    const codes = Array.isArray(parsed.exemptMethodCodes)
+        ? [
+            ...new Set(parsed.exemptMethodCodes
+                .filter((code) => typeof code === 'string' && code.trim() !== '')
+                .map(normalizeFulfillmentPolicyMethodCode)),
+        ].slice(0, FULFILLMENT_PAYMENT_POLICY_EXEMPT_METHODS_MAX)
+        : [];
+    return { requireFullPayment: parsed.requireFullPayment === true, exemptMethodCodes: codes };
+}
+/** Every way `policy` breaks the schema, one entry per field. */
+function problemsOf(policy) {
+    const problems = [];
+    const add = (field, message) => problems.push({ field, code: 'FULFILLMENT_PAYMENT_POLICY_INVALID', message });
+    if (!isRecord(policy)) {
+        add('policy', 'Pass the whole policy as an object: read it with get(), change it, send it back.');
+        return problems;
+    }
+    if (typeof policy.requireFullPayment !== 'boolean') {
+        add('requireFullPayment', 'requireFullPayment must be true or false.');
+    }
+    const codes = policy.exemptMethodCodes;
+    if (!Array.isArray(codes)) {
+        add('exemptMethodCodes', 'exemptMethodCodes must be a list of payment method codes.');
+    }
+    else if (codes.some((code) => typeof code !== 'string' || code.trim() === '')) {
+        add('exemptMethodCodes', 'exemptMethodCodes may hold only non-blank payment method codes.');
+    }
+    else if (codes.some((code) => code.trim().length > FULFILLMENT_PAYMENT_POLICY_METHOD_CODE_MAX_LENGTH)) {
+        add('exemptMethodCodes', `A payment method code is at most ${String(FULFILLMENT_PAYMENT_POLICY_METHOD_CODE_MAX_LENGTH)} characters.`);
+    }
+    else if (new Set(codes.map((code) => normalizeFulfillmentPolicyMethodCode(code))).size !==
+        codes.length) {
+        add('exemptMethodCodes', 'exemptMethodCodes names a payment method code more than once (codes are compared ignoring case).');
+    }
+    else if (codes.length > FULFILLMENT_PAYMENT_POLICY_EXEMPT_METHODS_MAX) {
+        add('exemptMethodCodes', `exemptMethodCodes may name at most ${String(FULFILLMENT_PAYMENT_POLICY_EXEMPT_METHODS_MAX)} payment methods.`);
+    }
+    return problems;
+}
+/** Exactly the schema's fields, in its order, codes trimmed: what the column stores. */
+function storedOf(policy) {
+    return {
+        requireFullPayment: policy.requireFullPayment,
+        exemptMethodCodes: policy.exemptMethodCodes.map((code) => code.trim()),
+    };
+}
+export function createFulfillmentPaymentPolicyModule(transport) {
+    const read = async (options) => {
+        const data = await transport.graphql({ api: 'admin', query: FULFILLMENT_PAYMENT_POLICY_QUERY }, options);
+        return data.activeChannel;
+    };
+    return {
+        async get(options) {
+            const channel = await read(options);
+            return readFulfillmentPaymentPolicy(channel.customFields?.fulfillmentPaymentPolicy ?? null);
+        },
+        async set(policy, options) {
+            const problems = problemsOf(policy);
+            if (problems.length > 0) {
+                throw new ValidationError({
+                    code: 'FULFILLMENT_PAYMENT_POLICY_INVALID',
+                    message: problems.map((problem) => problem.message).join(' '),
+                    status: 400,
+                    service: 'vendure',
+                    details: problems,
+                });
+            }
+            // `updateChannel` needs the id, and the active channel is the one the client is scoped
+            // to: read it with the SAME call options, so a per-call tenant writes its own channel.
+            const { id } = await read(options);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_FULFILLMENT_PAYMENT_POLICY_MUTATION,
+                variables: {
+                    // The column is `text` holding JSON, so it is sent as a string.
+                    input: {
+                        id,
+                        customFields: { fulfillmentPaymentPolicy: JSON.stringify(storedOf(policy)) },
+                    },
+                },
+            }, options);
+            if (isErrorResult(data.updateChannel))
+                throw errorFromErrorResult(data.updateChannel);
+            return readFulfillmentPaymentPolicy(data.updateChannel.customFields?.fulfillmentPaymentPolicy ?? null);
+        },
+    };
+}