@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/orders/deposit-policy.js

@@ -0,0 +1,202 @@
+import { errorFromErrorResult, isErrorResult, ValidationError, } from '@sixtyninecommerce/core';
+// The bounds of the meta catalog's `order_deposit_policy` schema
+// (`packages/shared/src/meta-catalog/settings-schemas.ts`), which the spec reads
+// back from that schema. Nothing on the engine validates the column on write, so
+// these are the only check a value gets before the engine reads it.
+/** The fewest days `autoCancelAfterDays` may be; `null` means never. */
+export const DEPOSIT_POLICY_AUTO_CANCEL_DAYS_MIN = 1;
+/** The largest `storefront.minimumPercent`: a whole percentage of the order total. */
+export const DEPOSIT_POLICY_MINIMUM_PERCENT_MAX = 100;
+/** The most payment method codes `storefront.methods` may name. */
+export const DEPOSIT_POLICY_STOREFRONT_METHODS_MAX = 50;
+/**
+ * The policy of a store that never set one, and of every field that cannot be
+ * read: deposits off, no minimum, no zero-deposit park, the reason kept from the
+ * shopper, never auto-cancelled, no online deposits.
+ */
+export const DEFAULT_ORDER_DEPOSIT_POLICY = Object.freeze({
+    enabled: false,
+    minimum: 0,
+    allowZeroDepositPark: false,
+    showParkReasonToCustomer: false,
+    autoCancelAfterDays: null,
+    storefront: Object.freeze({ enabled: false, methods: [], minimumPercent: 0 }),
+});
+const POLICY_FIELDS = /* GraphQL */ `
+  id
+  customFields {
+    orderDepositPolicy
+  }
+`;
+export const ORDER_DEPOSIT_POLICY_QUERY = /* GraphQL */ `
+  query OrderDepositPolicy {
+    activeChannel { ${POLICY_FIELDS} }
+  }
+`;
+export const SET_ORDER_DEPOSIT_POLICY_MUTATION = /* GraphQL */ `
+  mutation SetOrderDepositPolicy($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);
+}
+const isWhole = (value) => typeof value === 'number' && Number.isSafeInteger(value);
+/**
+ * The column, read as the engine reads it (`resolveDepositPolicy` in
+ * `services/vendure/src/payment/deposit-policy.ts`): anything unreadable is its
+ * default.
+ */
+function readOrderDepositPolicy(raw) {
+    let parsed = raw;
+    if (typeof raw === 'string') {
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            parsed = null;
+        }
+    }
+    if (!isRecord(parsed))
+        return copyOf(DEFAULT_ORDER_DEPOSIT_POLICY);
+    return {
+        enabled: parsed.enabled === true,
+        minimum: isWhole(parsed.minimum) && parsed.minimum >= 0 ? parsed.minimum : 0,
+        allowZeroDepositPark: parsed.allowZeroDepositPark === true,
+        showParkReasonToCustomer: parsed.showParkReasonToCustomer === true,
+        autoCancelAfterDays: isWhole(parsed.autoCancelAfterDays) &&
+            parsed.autoCancelAfterDays >= DEPOSIT_POLICY_AUTO_CANCEL_DAYS_MIN
+            ? parsed.autoCancelAfterDays
+            : null,
+        storefront: readStorefront(parsed.storefront),
+    };
+}
+function readStorefront(raw) {
+    if (!isRecord(raw))
+        return { enabled: false, methods: [], minimumPercent: 0 };
+    // Only non-blank string codes, once each and at most 50: a stray `null` or a
+    // number must not allow a method nobody named.
+    const methods = Array.isArray(raw.methods)
+        ? [
+            ...new Set(raw.methods.filter((code) => typeof code === 'string' && code.trim() !== '')),
+        ].slice(0, DEPOSIT_POLICY_STOREFRONT_METHODS_MAX)
+        : [];
+    const percent = raw.minimumPercent;
+    return {
+        enabled: raw.enabled === true,
+        methods,
+        minimumPercent: isWhole(percent) && percent >= 0 && percent <= DEPOSIT_POLICY_MINIMUM_PERCENT_MAX
+            ? percent
+            : 0,
+    };
+}
+function copyOf(policy) {
+    return {
+        ...policy,
+        storefront: { ...policy.storefront, methods: [...policy.storefront.methods] },
+    };
+}
+/** Every way `policy` breaks the schema, one entry per field. */
+function problemsOf(policy) {
+    const problems = [];
+    const add = (field, message) => problems.push({ field, code: 'DEPOSIT_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;
+    }
+    for (const field of ['enabled', 'allowZeroDepositPark', 'showParkReasonToCustomer']) {
+        if (typeof policy[field] !== 'boolean')
+            add(field, `${field} must be true or false.`);
+    }
+    if (!(isWhole(policy.minimum) && policy.minimum >= 0)) {
+        add('minimum', 'minimum must be a whole number of minor units, 0 or more.');
+    }
+    const days = policy.autoCancelAfterDays;
+    if (days !== null && !(isWhole(days) && days >= DEPOSIT_POLICY_AUTO_CANCEL_DAYS_MIN)) {
+        add('autoCancelAfterDays', 'autoCancelAfterDays must be null (never) or a whole number of days, 1 or more.');
+    }
+    const storefront = policy.storefront;
+    if (!isRecord(storefront)) {
+        add('storefront', 'storefront must be an object: { enabled, methods, minimumPercent }.');
+        return problems;
+    }
+    if (typeof storefront.enabled !== 'boolean') {
+        add('storefront.enabled', 'storefront.enabled must be true or false.');
+    }
+    const methods = storefront.methods;
+    if (!Array.isArray(methods)) {
+        add('storefront.methods', 'storefront.methods must be an array of payment method codes.');
+    }
+    else if (methods.some((code) => typeof code !== 'string' || code.trim() === '')) {
+        add('storefront.methods', 'storefront.methods may hold only non-blank payment method codes.');
+    }
+    else if (new Set(methods).size !== methods.length) {
+        add('storefront.methods', 'storefront.methods names a payment method code more than once.');
+    }
+    else if (methods.length > DEPOSIT_POLICY_STOREFRONT_METHODS_MAX) {
+        add('storefront.methods', `storefront.methods may name at most ${String(DEPOSIT_POLICY_STOREFRONT_METHODS_MAX)} payment methods.`);
+    }
+    const percent = storefront.minimumPercent;
+    if (!(isWhole(percent) && percent >= 0 && percent <= DEPOSIT_POLICY_MINIMUM_PERCENT_MAX)) {
+        add('storefront.minimumPercent', 'storefront.minimumPercent must be a whole percentage from 0 to 100.');
+    }
+    return problems;
+}
+/** Exactly the schema's fields, in its order: what the column stores. */
+function storedOf(policy) {
+    return {
+        enabled: policy.enabled,
+        minimum: policy.minimum,
+        allowZeroDepositPark: policy.allowZeroDepositPark,
+        showParkReasonToCustomer: policy.showParkReasonToCustomer,
+        autoCancelAfterDays: policy.autoCancelAfterDays,
+        storefront: {
+            enabled: policy.storefront.enabled,
+            methods: [...policy.storefront.methods],
+            minimumPercent: policy.storefront.minimumPercent,
+        },
+    };
+}
+export function createOrderDepositPolicyModule(transport) {
+    const read = async (options) => {
+        const data = await transport.graphql({ api: 'admin', query: ORDER_DEPOSIT_POLICY_QUERY }, options);
+        return data.activeChannel;
+    };
+    return {
+        async get(options) {
+            const channel = await read(options);
+            return readOrderDepositPolicy(channel.customFields?.orderDepositPolicy ?? null);
+        },
+        async set(policy, options) {
+            const problems = problemsOf(policy);
+            if (problems.length > 0) {
+                throw new ValidationError({
+                    code: 'DEPOSIT_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 rather than the client's.
+            const { id } = await read(options);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_ORDER_DEPOSIT_POLICY_MUTATION,
+                variables: {
+                    // The column is `text` holding JSON (the schema describes the
+                    // DECODED value), so it is sent as a string.
+                    input: { id, customFields: { orderDepositPolicy: JSON.stringify(storedOf(policy)) } },
+                },
+            }, options);
+            if (isErrorResult(data.updateChannel))
+                throw errorFromErrorResult(data.updateChannel);
+            return readOrderDepositPolicy(data.updateChannel.customFields?.orderDepositPolicy ?? null);
+        },
+    };
+}