@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/shipping/methods.js

@@ -0,0 +1,240 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+import { assertDeleted, fieldOf, vendureListPage, } from '../catalog/types.js';
+/** A store has a handful; one page holds them. */
+const DEFAULT_PAGE_SIZE = 100;
+/**
+ * Vendure's list queries add no ORDER BY of their own, and `skip/take` over an unordered query
+ * can repeat or skip rows between two requests: id is the one unique key a sort can name.
+ */
+const BY_ID = { id: 'ASC' };
+const OPERATION_FIELDS = /* GraphQL */ `
+  code
+  args {
+    name
+    value
+  }
+`;
+const SUMMARY_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  updatedAt
+  code
+  name
+  fulfillmentHandlerCode
+  calculator { ${OPERATION_FIELDS} }
+  customFields {
+    enabled
+    enabledInStorefront
+  }
+`;
+/** One selection for the single read and both writes, so all three answer the same method. */
+const METHOD_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  updatedAt
+  code
+  name
+  description
+  fulfillmentHandlerCode
+  calculator { ${OPERATION_FIELDS} }
+  checker { ${OPERATION_FIELDS} }
+  translations {
+    id
+    languageCode
+    name
+    description
+  }
+  customFields {
+    enabled
+    enabledInStorefront
+    exactManaged
+    extraParcelPrice
+  }
+`;
+export const SHIPPING_METHODS_QUERY = /* GraphQL */ `
+  query StoreShippingMethods($options: ShippingMethodListOptions) {
+    shippingMethods(options: $options) {
+      items { ${SUMMARY_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const SHIPPING_METHOD_QUERY = /* GraphQL */ `
+  query StoreShippingMethod($id: ID!) {
+    shippingMethod(id: $id) { ${METHOD_FIELDS} }
+  }
+`;
+export const CREATE_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation CreateStoreShippingMethod($input: CreateShippingMethodInput!) {
+    createShippingMethod(input: $input) { ${METHOD_FIELDS} }
+  }
+`;
+export const UPDATE_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation UpdateStoreShippingMethod($input: UpdateShippingMethodInput!) {
+    updateShippingMethod(input: $input) { ${METHOD_FIELDS} }
+  }
+`;
+export const DELETE_SHIPPING_METHOD_MUTATION = /* GraphQL */ `
+  mutation DeleteStoreShippingMethod($id: ID!) {
+    deleteShippingMethod(id: $id) {
+      result
+      message
+    }
+  }
+`;
+const invalidInput = (message) => new ValidationError({
+    code: 'INVALID_SHIPPING_METHOD_INPUT',
+    message,
+    status: 400,
+    service: 'vendure',
+});
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** A handler-like operation 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 store switches under
+ * `customFields`. The range of `extraParcelPrice` is the engine's to judge.
+ */
+function sharedInput(input) {
+    const out = {};
+    if (input.code !== undefined) {
+        if (typeof input.code !== 'string' || input.code === '') {
+            throw invalidInput('code must be a non-empty string.');
+        }
+        out.code = input.code;
+    }
+    if (input.fulfillmentHandler !== undefined) {
+        if (typeof input.fulfillmentHandler !== 'string' || input.fulfillmentHandler === '') {
+            throw invalidInput('fulfillmentHandler must be a fulfillment handler code.');
+        }
+        out.fulfillmentHandler = input.fulfillmentHandler;
+    }
+    if (input.checker === null) {
+        throw invalidInput('Every shipping method has a checker: send default-shipping-eligibility-checker for "everyone".');
+    }
+    if (input.checker !== undefined)
+        out.checker = operationInput(input.checker, 'checker');
+    if (input.calculator !== undefined) {
+        out.calculator = operationInput(input.calculator, 'calculator');
+    }
+    if (input.translations !== undefined)
+        out.translations = translationsInput(input.translations);
+    const customFields = {};
+    for (const flag of ['enabled', 'enabledInStorefront']) {
+        const value = input[flag];
+        if (value === undefined)
+            continue;
+        if (typeof value !== 'boolean')
+            throw invalidInput(`${flag} must be true or false.`);
+        customFields[flag] = value;
+    }
+    const extra = input.extraParcelPrice;
+    if (extra !== undefined) {
+        if (extra !== null && (typeof extra !== 'number' || !Number.isSafeInteger(extra))) {
+            throw invalidInput('extraParcelPrice must be a whole number of minor units, or null.');
+        }
+        customFields.extraParcelPrice = extra;
+    }
+    if (Object.keys(customFields).length > 0)
+        out.customFields = customFields;
+    return out;
+}
+const toSummary = (method) => ({
+    id: method.id,
+    code: method.code,
+    name: method.name,
+    fulfillmentHandlerCode: method.fulfillmentHandlerCode,
+    calculator: method.calculator,
+    // A switch the engine did not answer (a method stored before it existed) reads as ON: the
+    // checkout's own rule (`shipping-method-enabled.ts` in the shipping-calculator plugin) is the same fail-open one.
+    enabled: method.customFields?.enabled !== false,
+    enabledInStorefront: method.customFields?.enabledInStorefront !== false,
+    createdAt: method.createdAt,
+    updatedAt: method.updatedAt,
+});
+const toMethod = (method) => {
+    const extra = method.customFields?.extraParcelPrice;
+    return {
+        ...toSummary(method),
+        description: method.description,
+        checker: method.checker,
+        translations: method.translations,
+        exactManaged: method.customFields?.exactManaged === true,
+        extraParcelPrice: typeof extra === 'number' ? extra : null,
+    };
+};
+const requireId = (id) => {
+    if (typeof id !== 'string' || id === '')
+        throw invalidInput('id must be a shipping method id.');
+    return id;
+};
+export function createShippingMethodsModule(transport) {
+    return {
+        list(options) {
+            return vendureListPage(transport, SHIPPING_METHODS_QUERY, 'shippingMethods', (skip, take) => ({ options: { skip, take, sort: BY_ID } }), { ...options, limit: options?.limit ?? DEFAULT_PAGE_SIZE }, toSummary);
+        },
+        async get(id, options) {
+            const method = await fieldOf(transport, SHIPPING_METHOD_QUERY, 'shippingMethod', { id: requireId(id) }, options);
+            return method ? toMethod(method) : null;
+        },
+        async create(input, options) {
+            if (!isObject(input))
+                throw invalidInput('A new shipping method must be an object.');
+            if (input.code === undefined)
+                throw invalidInput('A shipping method needs a code.');
+            if (input.fulfillmentHandler === undefined) {
+                throw invalidInput('A shipping method needs a fulfillment handler.');
+            }
+            if (input.checker === undefined)
+                throw invalidInput('A shipping method needs a checker.');
+            if (input.calculator === undefined) {
+                throw invalidInput('A shipping method needs a calculator.');
+            }
+            if (input.translations === undefined) {
+                throw invalidInput('A shipping method needs its name in at least one language.');
+            }
+            return toMethod(await fieldOf(transport, CREATE_SHIPPING_METHOD_MUTATION, 'createShippingMethod', { input: sharedInput(input) }, options));
+        },
+        async update(id, patch, options) {
+            const methodId = requireId(id);
+            if (!isObject(patch))
+                throw invalidInput('The change to a shipping method must be an object.');
+            const input = sharedInput(patch);
+            // The engine's input REQUIRES a translations list; an empty one changes no name.
+            return toMethod(await fieldOf(transport, UPDATE_SHIPPING_METHOD_MUTATION, 'updateShippingMethod', { input: { id: methodId, translations: [], ...input } }, options));
+        },
+        async delete(id, options) {
+            assertDeleted('SHIPPING_METHOD_NOT_DELETED', [
+                await fieldOf(transport, DELETE_SHIPPING_METHOD_MUTATION, 'deleteShippingMethod', { id: requireId(id) }, options),
+            ]);
+        },
+    };
+}