@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/catalog/variant-find.js

@@ -0,0 +1,239 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+import { createSearchModule, escapeSearchFilterValue } from '../search/index.js';
+import { fieldOf } from './types.js';
+/** The most variants one `variants.find` answers. */
+export const MAX_VARIANT_FIND_TAKE = 500;
+/** The most products one `variants.find` search reads (`take / perProduct`, rounded up). */
+export const MAX_VARIANT_FIND_PRODUCTS = 100;
+const FOUND_VARIANT_PRODUCT_FIELDS = /* GraphQL */ `
+  id
+  name
+  slug
+  featuredAsset {
+    id
+    preview
+  }
+`;
+/**
+ * What a picker reads of a variant. `storePrice`, never core's `price` / `priceWithTax`: those
+ * throw for a variant the store has no price for, and one such variant would empty the answer.
+ */
+export const FOUND_VARIANT_FIELDS = /* GraphQL */ `
+  id
+  name
+  sku
+  enabled
+  storePrice {
+    price
+    priceWithTax
+    currencyCode
+  }
+  trackInventory
+  outOfStockThreshold
+  useGlobalOutOfStockThreshold
+  stockOnHand
+  stockAllocated
+  stockLevels {
+    stockLocationId
+    stockOnHand
+    stockAllocated
+    stockLocation {
+      id
+      name
+    }
+  }
+`;
+/** A found variant with its product: the selection of every list that answers variants flat. */
+export const FOUND_VARIANT_WITH_PRODUCT_FIELDS = /* GraphQL */ `
+  ${FOUND_VARIANT_FIELDS}
+  product {
+    ${FOUND_VARIANT_PRODUCT_FIELDS}
+  }
+`;
+export const FIND_VARIANTS_BY_IDS_QUERY = /* GraphQL */ `
+  query CatalogFindVariantsByIds($options: ProductVariantListOptions) {
+    productVariants(options: $options) {
+      items {
+        ${FOUND_VARIANT_WITH_PRODUCT_FIELDS}
+      }
+      totalItems
+    }
+  }
+`;
+/**
+ * The variants of some products, bounded PER PRODUCT (`variantList`, never `variants`, which the
+ * engine answers whole and then cuts at 1,000 without saying so).
+ */
+export const FIND_VARIANTS_OF_PRODUCTS_QUERY = /* GraphQL */ `
+  query CatalogFindVariantsOfProducts(
+    $options: ProductListOptions
+    $variantOptions: ProductVariantListOptions
+  ) {
+    products(options: $options) {
+      items {
+        ${FOUND_VARIANT_PRODUCT_FIELDS}
+        variantList(options: $variantOptions) {
+          items {
+            ${FOUND_VARIANT_FIELDS}
+          }
+          totalItems
+        }
+      }
+      totalItems
+    }
+  }
+`;
+export function toFoundVariant(wire) {
+    const { stockLevels, product, ...rest } = wire;
+    return {
+        ...rest,
+        stockLevels: stockLevels.map((level) => ({
+            stockLocationId: level.stockLocationId,
+            stockLocationName: level.stockLocation?.name ?? '',
+            stockOnHand: level.stockOnHand,
+            stockAllocated: level.stockAllocated,
+        })),
+        product: {
+            id: product.id,
+            name: product.name,
+            slug: product.slug,
+            featuredAsset: product.featuredAsset,
+        },
+    };
+}
+function invalid(message) {
+    return new ValidationError({
+        code: 'VARIANT_FIND_INPUT_INVALID',
+        message,
+        status: 400,
+        service: 'vendure',
+    });
+}
+function wholeNumber(value, low, high) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= low && value <= high;
+}
+/** A literal inside a regular expression the engine evaluates (Postgres `~*`). */
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function criterionOf(input) {
+    const given = ['ids', 'term', 'skuPrefix'].filter((key) => input[key] !== undefined);
+    if (given.length !== 1) {
+        throw invalid(`Say which variants with exactly one of ids, term and skuPrefix; got ${given.length === 0 ? 'none' : given.join(' and ')}.`);
+    }
+    if (input.ids !== undefined) {
+        if (!Array.isArray(input.ids) || input.ids.some((id) => typeof id !== 'string' || id === '')) {
+            throw invalid('ids must be a list of variant ids.');
+        }
+        return { kind: 'ids', ids: [...new Set(input.ids)] };
+    }
+    const key = input.term !== undefined ? 'term' : 'skuPrefix';
+    const text = input[key];
+    if (typeof text !== 'string' || text.trim() === '') {
+        throw invalid(`${key} must be text to search for; an empty one finds nothing.`);
+    }
+    return key === 'term'
+        ? { kind: 'term', term: text.trim() }
+        : { kind: 'skuPrefix', prefix: text.trim() };
+}
+/** The call's options with the currency the prices are asked in. */
+function pricedIn(options, currencyCode) {
+    if (currencyCode === undefined)
+        return options;
+    if (typeof currencyCode !== 'string' || currencyCode.trim() === '') {
+        throw invalid('currencyCode must be an ISO 4217 code, or left out for the store default.');
+    }
+    return { ...options, tenant: { ...options?.tenant, currency: currencyCode } };
+}
+async function findByIds(transport, ids, take, options) {
+    if (ids.length > take) {
+        throw invalid(`ids names ${String(ids.length)} variants and take is ${String(take)}. Raise take, or ask for fewer.`);
+    }
+    if (ids.length === 0)
+        return { items: [], products: [] };
+    const list = await fieldOf(transport, FIND_VARIANTS_BY_IDS_QUERY, 'productVariants', 
+    // Sorted so the engine's page is one total order; the answer is re-ordered below.
+    { options: { filter: { id: { in: ids } }, take: ids.length, sort: { id: 'ASC' } } }, options);
+    const found = new Map(list.items.map((row) => [row.id, row]));
+    return {
+        items: ids.flatMap((id) => {
+            const row = found.get(id);
+            return row ? [toFoundVariant(row)] : [];
+        }),
+        products: [],
+    };
+}
+async function findBySearch(transport, criterion, take, perProduct, options, pricedOptions) {
+    const productCount = Math.ceil(take / perProduct);
+    if (productCount > MAX_VARIANT_FIND_PRODUCTS) {
+        throw invalid(`take ${String(take)} at ${String(perProduct)} per product reads ${String(productCount)} products; at most ${String(MAX_VARIANT_FIND_PRODUCTS)}. Raise perProduct or lower take.`);
+    }
+    // Which products, and in what order, is the index's answer (`search.index`, never a copy of
+    // it): relevance for a term, the product's name for a SKU prefix.
+    const hits = await createSearchModule(transport).index('products', criterion.kind === 'term'
+        ? { term: criterion.term, take: productCount }
+        : {
+            term: '',
+            filters: [`skus STARTS WITH "${escapeSearchFilterValue(criterion.prefix)}"`],
+            sort: 'name',
+            take: productCount,
+        }, options);
+    const productIds = hits.items.map((hit) => hit.id);
+    if (productIds.length === 0)
+        return { items: [], products: [] };
+    const list = await fieldOf(transport, FIND_VARIANTS_OF_PRODUCTS_QUERY, 'products', {
+        options: { filter: { id: { in: productIds } }, take: productIds.length, sort: { id: 'ASC' } },
+        variantOptions: {
+            take: perProduct,
+            // A total order, so a bounded page is the same page on every read. By id alone: the
+            // engine applies the keys of a sort in the order its schema declares them, where `id`
+            // precedes `position`, so the `position, id` the pickers used to send was this order.
+            sort: { id: 'ASC' },
+            // Only a SKU search narrows the variants. A term matches the PRODUCT (its name, its
+            // description), and a variant's name is its options, so filtering variants by it would
+            // answer a product with nothing to pick.
+            ...(criterion.kind === 'skuPrefix'
+                ? { filter: { sku: { regex: `^${escapeRegex(criterion.prefix)}` } } }
+                : {}),
+        },
+    }, pricedOptions);
+    const read = new Map(list.items.map((product) => [product.id, product]));
+    const items = [];
+    const products = [];
+    for (const id of productIds) {
+        const room = take - items.length;
+        if (room <= 0)
+            break;
+        // The index can name a product the store no longer holds: it is updated after each change.
+        const product = read.get(id);
+        if (!product)
+            continue;
+        const rows = product.variantList.items.slice(0, room);
+        if (rows.length === 0)
+            continue;
+        for (const row of rows)
+            items.push(toFoundVariant({ ...row, product }));
+        products.push({ id: product.id, shown: rows.length, total: product.variantList.totalItems });
+    }
+    return { items, products };
+}
+/** `catalog.variants.find`; its contract is on `VariantsModule.find`. */
+export async function findVariants(transport, input, options) {
+    if (typeof input !== 'object' || input === null)
+        throw invalid('find takes an input object.');
+    const criterion = criterionOf(input);
+    const { take, perProduct } = input;
+    if (!wholeNumber(take, 1, MAX_VARIANT_FIND_TAKE)) {
+        throw invalid(`take must be a whole number from 1 to ${String(MAX_VARIANT_FIND_TAKE)}.`);
+    }
+    const pricedOptions = pricedIn(options, input.currencyCode);
+    if (criterion.kind === 'ids') {
+        if (perProduct !== undefined)
+            throw invalid('perProduct bounds a search; ids takes none.');
+        return findByIds(transport, criterion.ids, take, pricedOptions);
+    }
+    if (perProduct !== undefined && !wholeNumber(perProduct, 1, take)) {
+        throw invalid(`perProduct must be a whole number from 1 to take (${String(take)}).`);
+    }
+    return findBySearch(transport, criterion, take, perProduct ?? Math.ceil(take / 10), options, pricedOptions);
+}