@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/catalog/products.js

@@ -0,0 +1,458 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+import { bulkProducts, readProductBulkRun, } from './products-bulk.js';
+import { ASSET_REF_FIELDS, assertDeleted, availabilityCustomFields, CATALOGUE_OWNERSHIP_FIELDS, DELETION_FIELDS, FACET_VALUE_REF_FIELDS, fieldOf, unwrapResult, vendureListPage, } from './types.js';
+import { assertPricesStateBasis, } from './variants.js';
+/** The engine's bound on one `exclude` or `include` call (`STORE_EXCLUSION_BATCH_LIMIT`). */
+export const MAX_STORE_EXCLUSION_PRODUCTS = 500;
+/**
+ * The engine's bounds on one `setAvailabilityInStores` or `availabilityInStores` call
+ * (`AVAILABILITY_*_LIMIT`).
+ */
+export const MAX_AVAILABILITY_PRODUCTS = 100;
+export const MAX_AVAILABILITY_STORES = 50;
+/** The engine's bound on each list of one {@link ProductsModule.setCollections} call. */
+export const MAX_PRODUCT_COLLECTION_IDS = 200;
+export const PRODUCT_FIELDS = /* GraphQL */ `
+  id
+  ${CATALOGUE_OWNERSHIP_FIELDS}
+  createdAt
+  updatedAt
+  languageCode
+  name
+  slug
+  description
+  enabled
+  featuredAsset { ${ASSET_REF_FIELDS} }
+  assets { ${ASSET_REF_FIELDS} }
+  facetValues { ${FACET_VALUE_REF_FIELDS} }
+  optionGroups {
+    id
+    code
+    name
+    options {
+      id
+      code
+      name
+    }
+  }
+  translations {
+    id
+    languageCode
+    name
+    slug
+    description
+  }
+  excludedFromStore
+  variantList(options: { take: 1 }) {
+    totalItems
+  }
+  customFields {
+    availabilityState
+    availableFrom
+    preorderLimit
+  }
+`;
+export const PRODUCTS_QUERY = /* GraphQL */ `
+  query CatalogProducts($options: ProductListOptions) {
+    products(options: $options) {
+      items { ${PRODUCT_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const PRODUCT_QUERY = /* GraphQL */ `
+  query CatalogProduct($id: ID!) {
+    product(id: $id) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const CREATE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogCreateProduct($input: CreateProductInput!) {
+    createProduct(input: $input) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const UPDATE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogUpdateProduct($input: UpdateProductInput!) {
+    updateProduct(input: $input) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const DELETE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogDeleteProduct($id: ID!) {
+    deleteProduct(id: $id) { ${DELETION_FIELDS} }
+  }
+`;
+export const CLONE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogCloneProduct($id: ID!) {
+    cloneProduct(id: $id)
+  }
+`;
+export const ADD_OPTION_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogAddOptionGroup($productId: ID!, $optionGroupId: ID!) {
+    addOptionGroupToProduct(productId: $productId, optionGroupId: $optionGroupId) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const REMOVE_OPTION_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogRemoveOptionGroup($productId: ID!, $optionGroupId: ID!, $force: Boolean) {
+    removeOptionGroupFromProduct(productId: $productId, optionGroupId: $optionGroupId, force: $force) {
+      ... on Product { ${PRODUCT_FIELDS} }
+      ... on ErrorResult {
+        errorCode
+        message
+      }
+    }
+  }
+`;
+export const EXCLUDE_PRODUCTS_FROM_STORE_MUTATION = /* GraphQL */ `
+  mutation CatalogExcludeProductsFromStore($productIds: [ID!]!) {
+    excludeProductsFromStore(productIds: $productIds) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const INCLUDE_PRODUCTS_IN_STORE_MUTATION = /* GraphQL */ `
+  mutation CatalogIncludeProductsInStore($productIds: [ID!]!) {
+    includeProductsInStore(productIds: $productIds) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const SET_ORGANIZATION_PRODUCT_AVAILABILITY_MUTATION = /* GraphQL */ `
+  mutation CatalogSetOrganizationProductAvailability(
+    $productIds: [ID!]!
+    $channelIds: [ID!]!
+    $available: Boolean!
+  ) {
+    setOrganizationProductAvailability(
+      productIds: $productIds
+      channelIds: $channelIds
+      available: $available
+    ) {
+      productId
+      channelId
+      action
+    }
+  }
+`;
+export const ORGANIZATION_PRODUCT_AVAILABILITY_QUERY = /* GraphQL */ `
+  query CatalogOrganizationProductAvailability($productIds: [ID!]!, $channelIds: [ID!]!) {
+    organizationProductAvailability(productIds: $productIds, channelIds: $channelIds) {
+      productId
+      channelId
+      state
+      localCopyId
+    }
+  }
+`;
+export const MAKE_LOCAL_COPY_MUTATION = /* GraphQL */ `
+  mutation CatalogMakeLocalCopy($productId: ID!, $skus: [LocalCopySkuInput!]) {
+    makeLocalCopy(productId: $productId, skus: $skus) {
+      product { ${PRODUCT_FIELDS} }
+      originalProductId
+      original
+      droppedOrganizationPropertyCount
+    }
+  }
+`;
+export const SET_PRODUCT_COLLECTIONS_MUTATION = /* GraphQL */ `
+  mutation CatalogSetProductCollections(
+    $productId: ID!
+    $collectionIds: [ID!]!
+    $fromCollectionIds: [ID!]
+  ) {
+    setProductCollections(
+      productId: $productId
+      collectionIds: $collectionIds
+      fromCollectionIds: $fromCollectionIds
+    ) {
+      added
+      removed
+      unchanged
+      notRemoved {
+        collectionId
+        reason
+      }
+    }
+  }
+`;
+export const SAVE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogSaveProduct($input: SaveProductInput!, $idempotencyKey: String) {
+    saveProduct(input: $input, idempotencyKey: $idempotencyKey) {
+      product { ${PRODUCT_FIELDS} }
+      collections {
+        added
+        removed
+        unchanged
+        notRemoved {
+          collectionId
+          reason
+        }
+      }
+      warnings {
+        code
+        message
+        propertyIds
+      }
+    }
+  }
+`;
+/**
+ * Lift the availability custom fields to first-class fields. A server older
+ * than the pre-order engine has no such fields and would refuse the document
+ * outright, so the defaults below only cover a NULL value, never an absent one.
+ */
+export function toProduct(wire) {
+    const { variantList, customFields, ...rest } = wire;
+    return {
+        ...rest,
+        variantCount: variantList.totalItems,
+        availabilityState: customFields?.availabilityState ?? 'none',
+        availableFrom: customFields?.availableFrom ?? null,
+        preorderLimit: customFields?.preorderLimit ?? null,
+    };
+}
+function toWireInput(input) {
+    const { availabilityState, availableFrom, preorderLimit, brand, condition, ...rest } = input;
+    const customFields = availabilityCustomFields({
+        availabilityState,
+        availableFrom,
+        preorderLimit,
+    });
+    if (brand !== undefined)
+        customFields.brand = brand;
+    if (condition !== undefined)
+        customFields.condition = condition;
+    return Object.keys(customFields).length > 0 ? { ...rest, customFields } : rest;
+}
+export function productFilter(filter) {
+    const out = {};
+    if (!filter)
+        return out;
+    if (filter.ids !== undefined)
+        out.id = { in: filter.ids };
+    if (filter.name !== undefined)
+        out.name = { contains: filter.name };
+    if (filter.sku !== undefined)
+        out.sku = { contains: filter.sku };
+    if (filter.enabled !== undefined)
+        out.enabled = { eq: filter.enabled };
+    if (filter.facetValueIds !== undefined)
+        out.facetValueId = { in: filter.facetValueIds };
+    if (filter.availabilityState !== undefined) {
+        out.availabilityState = { eq: filter.availabilityState };
+    }
+    return out;
+}
+function refuse(code, message) {
+    return new ValidationError({ code, message, status: 400, service: 'vendure' });
+}
+/** Distinct ids the way the engine counts them: it stores a uuid lower-case. */
+function distinctCount(ids) {
+    return new Set(ids.map((id) => String(id).toLowerCase())).size;
+}
+function assertExclusionBatch(productIds) {
+    const count = distinctCount(productIds);
+    if (count <= MAX_STORE_EXCLUSION_PRODUCTS)
+        return;
+    throw refuse('STORE_EXCLUSION_INPUT_INVALID', `Exclude or include at most ${String(MAX_STORE_EXCLUSION_PRODUCTS)} products per call; this one named ${String(count)}. Split it into smaller calls. Nothing was sent.`);
+}
+function assertAvailabilityInput(input, verb = 'set') {
+    const bounds = [
+        ['products', input?.productIds, MAX_AVAILABILITY_PRODUCTS],
+        ['stores', input?.channelIds, MAX_AVAILABILITY_STORES],
+    ];
+    for (const [noun, ids, limit] of bounds) {
+        if (!Array.isArray(ids) || ids.length === 0) {
+            throw refuse('ORGANIZATION_AVAILABILITY_INPUT_INVALID', `Name at least one of the ${noun}. Nothing was sent.`);
+        }
+        const count = distinctCount(ids);
+        if (count > limit) {
+            throw refuse('ORGANIZATION_AVAILABILITY_INPUT_INVALID', `At most ${String(limit)} ${noun} can be ${verb} in one call; this one named ${String(count)}. Split it into smaller calls. Nothing was sent.`);
+        }
+    }
+    if (verb === 'set' && typeof input.available !== 'boolean') {
+        throw refuse('ORGANIZATION_AVAILABILITY_INPUT_INVALID', '`available` must be true (offer the products) or false (stop offering them). Nothing was sent.');
+    }
+}
+/** The engine's check of each list (`PRODUCT_COLLECTIONS_INPUT_INVALID`), before sending. */
+function assertCollectionLists(lists) {
+    for (const [argument, ids] of Object.entries(lists)) {
+        if (ids === undefined)
+            continue;
+        if (!Array.isArray(ids)) {
+            throw refuse('PRODUCT_COLLECTIONS_INPUT_INVALID', `${argument} must be a list of collection ids. Nothing was sent.`);
+        }
+        if (ids.length > MAX_PRODUCT_COLLECTION_IDS) {
+            throw refuse('PRODUCT_COLLECTIONS_INPUT_INVALID', `Name at most ${String(MAX_PRODUCT_COLLECTION_IDS)} collections in ${argument}; this call named ${String(ids.length)}. Nothing was sent.`);
+        }
+        if (distinctCount(ids) !== ids.length) {
+            throw refuse('PRODUCT_COLLECTIONS_INPUT_INVALID', `${argument} names a collection more than once. Name each collection once. Nothing was sent.`);
+        }
+    }
+}
+export function createProductsModule(transport) {
+    const write = async (document, field, variables, options) => {
+        return toProduct(await fieldOf(transport, document, field, variables, options));
+    };
+    return {
+        async list(options) {
+            const filter = productFilter(options?.filter);
+            return vendureListPage(transport, PRODUCTS_QUERY, 'products', (skip, take) => ({
+                options: {
+                    skip,
+                    take,
+                    ...(Object.keys(filter).length > 0 ? { filter, filterOperator: 'AND' } : {}),
+                    ...(options?.sort ? { sort: { [options.sort.field]: options.sort.direction } } : {}),
+                },
+            }), options, toProduct);
+        },
+        async get(id, options) {
+            const product = await fieldOf(transport, PRODUCT_QUERY, 'product', { id }, options);
+            return product ? toProduct(product) : null;
+        },
+        // `async` so every refusal below — including `toWireInput`'s datetime
+        // check — arrives as a rejection, never as a synchronous throw a caller's
+        // `.catch()` would miss.
+        async create(input, options) {
+            if (!Array.isArray(input.translations) || input.translations.length === 0) {
+                throw new ValidationError({
+                    code: 'INVALID_PRODUCT_INPUT',
+                    message: 'A product needs at least one translation (languageCode + name).',
+                    status: 400,
+                    service: 'vendure',
+                });
+            }
+            return write(CREATE_PRODUCT_MUTATION, 'createProduct', { input: toWireInput(input) }, options);
+        },
+        async update(input, options) {
+            return write(UPDATE_PRODUCT_MUTATION, 'updateProduct', { input: toWireInput(input) }, options);
+        },
+        async delete(id, options) {
+            assertDeleted('PRODUCT_NOT_DELETED', [
+                await fieldOf(transport, DELETE_PRODUCT_MUTATION, 'deleteProduct', { id }, options),
+            ]);
+        },
+        async clone(id, options) {
+            return fieldOf(transport, CLONE_PRODUCT_MUTATION, 'cloneProduct', { id }, options);
+        },
+        addOptionGroup(productId, optionGroupId, options) {
+            return write(ADD_OPTION_GROUP_MUTATION, 'addOptionGroupToProduct', { productId, optionGroupId }, options);
+        },
+        async removeOptionGroup(productId, optionGroupId, options) {
+            const result = await fieldOf(transport, REMOVE_OPTION_GROUP_MUTATION, 'removeOptionGroupFromProduct', { productId, optionGroupId, force: options?.force ?? false }, options);
+            return toProduct(unwrapResult(result));
+        },
+        async exclude(productIds, options) {
+            assertExclusionBatch(productIds);
+            if (productIds.length === 0)
+                return [];
+            const rows = await fieldOf(transport, EXCLUDE_PRODUCTS_FROM_STORE_MUTATION, 'excludeProductsFromStore', { productIds }, options);
+            return rows.map(toProduct);
+        },
+        async include(productIds, options) {
+            assertExclusionBatch(productIds);
+            if (productIds.length === 0)
+                return [];
+            const rows = await fieldOf(transport, INCLUDE_PRODUCTS_IN_STORE_MUTATION, 'includeProductsInStore', { productIds }, options);
+            return rows.map(toProduct);
+        },
+        async setAvailabilityInStores(input, options) {
+            assertAvailabilityInput(input);
+            return fieldOf(transport, SET_ORGANIZATION_PRODUCT_AVAILABILITY_MUTATION, 'setOrganizationProductAvailability', {
+                productIds: input.productIds,
+                channelIds: input.channelIds,
+                available: input.available,
+            }, options);
+        },
+        async availabilityInStores(input, options) {
+            assertAvailabilityInput(input, 'read');
+            return fieldOf(transport, ORGANIZATION_PRODUCT_AVAILABILITY_QUERY, 'organizationProductAvailability', { productIds: input.productIds, channelIds: input.channelIds }, options);
+        },
+        async makeLocalCopy(productId, options) {
+            const { skus, ...call } = options ?? {};
+            const result = await fieldOf(transport, MAKE_LOCAL_COPY_MUTATION, 'makeLocalCopy', {
+                productId,
+                skus: skus === undefined
+                    ? null
+                    : skus.map(({ productVariantId, sku }) => ({ productVariantId, sku })),
+            }, call);
+            return { ...result, product: toProduct(result.product) };
+        },
+        async setCollections(productId, collectionIds, options) {
+            const { from, ...call } = options ?? {};
+            assertCollectionLists({ collectionIds, fromCollectionIds: from });
+            return fieldOf(transport, SET_PRODUCT_COLLECTIONS_MUTATION, 'setProductCollections', {
+                productId,
+                collectionIds: [...collectionIds],
+                fromCollectionIds: from === undefined ? null : [...from],
+            }, call);
+        },
+        async save(input, options) {
+            assertCollectionLists({
+                collectionIds: input.collectionIds,
+                fromCollectionIds: input.fromCollectionIds,
+            });
+            await assertPricesStateBasis(transport, input.variants ?? [], options);
+            const result = await fieldOf(transport, SAVE_PRODUCT_MUTATION, 'saveProduct', { input: toWireSaveInput(input), idempotencyKey: options?.idempotencyKey ?? null }, options);
+            return { ...result, product: toProduct(result.product) };
+        },
+        bulk(input, options) {
+            return bulkProducts(transport, input, options);
+        },
+        bulkRun(runId, options) {
+            return readProductBulkRun(transport, runId, options);
+        },
+    };
+}
+/** The variant fields a save writes as custom fields on the wire. */
+const SAVE_VARIANT_CUSTOM_FIELDS = [
+    'minOrderQuantity',
+    'salesUnit',
+    'cost',
+    'packageWeightGrams',
+    'packageLengthCm',
+    'packageWidthCm',
+    'packageHeightCm',
+    'parcelCapacity',
+    'parcelPacking',
+    'backorderPolicy',
+    'backorderLimit',
+    'gtin',
+    'mpn',
+];
+/** The SDK's flat save as the engine's `SaveProductInput`: custom fields nested, no basis. */
+function toWireSaveInput(input) {
+    const wire = { id: input.id, languageCode: input.languageCode };
+    if (input.product) {
+        const { availabilityState, availableFrom, preorderLimit, brand, condition, ...rest } = input.product;
+        const customFields = availabilityCustomFields({
+            availabilityState,
+            availableFrom,
+            preorderLimit,
+        });
+        if (brand !== undefined)
+            customFields.brand = brand;
+        if (condition !== undefined)
+            customFields.condition = condition;
+        wire.product = Object.keys(customFields).length > 0 ? { ...rest, customFields } : rest;
+    }
+    if (input.variants) {
+        wire.variants = input.variants.map((variant) => {
+            const { availabilityState, availableFrom, preorderLimit, priceBasis, ...rest } = variant;
+            void priceBasis;
+            const customFields = availabilityCustomFields({
+                availabilityState,
+                availableFrom,
+                preorderLimit,
+            });
+            const out = { ...rest };
+            for (const key of SAVE_VARIANT_CUSTOM_FIELDS) {
+                if (key in out) {
+                    if (out[key] !== undefined)
+                        customFields[key] = out[key];
+                    delete out[key];
+                }
+            }
+            return Object.keys(customFields).length > 0 ? { ...out, customFields } : out;
+        });
+    }
+    for (const key of ['collectionIds', 'fromCollectionIds', 'propertyValues']) {
+        if (input[key] !== undefined)
+            wire[key] = input[key];
+    }
+    return wire;
+}