@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/catalog/collections.js

@@ -1,4 +1,30 @@
-import { ASSET_REF_FIELDS, assertDeleted, CATALOGUE_OWNERSHIP_FIELDS, DELETION_FIELDS, fieldOf, vendureListPage, } from './types.js';
+import { pageFromVendureList, ValidationError, } from '@sixtyninecommerce/core';
+import { createSearchModule } from '../search/index.js';
+import { ASSET_REF_FIELDS, assertDeleted, CATALOGUE_OWNERSHIP_FIELDS, DEFAULT_PAGE_SIZE, DELETION_FIELDS, fieldOf, toAssetRef, vendureListPage, } from './types.js';
+/** The most collections one {@link CollectionsModule.search} answers. */
+export const MAX_COLLECTION_SEARCH_TAKE = 100;
+const SEO_FIELDS = /* GraphQL */ `
+  customFields {
+    isRoutable
+    isCanonical
+    noindex
+    nofollow
+    metaRobotsMaxImagePreview
+    socialImageId
+    socialOgType
+    twitterCardType
+  }
+`;
+const TRANSLATION_SEO_FIELDS = /* GraphQL */ `
+  customFields {
+    seoTitle
+    seoDescription
+    canonicalUrl
+    socialTitle
+    socialDescription
+    socialImageAlt
+  }
+`;
 export const COLLECTION_FIELDS = /* GraphQL */ `
   id
   ${CATALOGUE_OWNERSHIP_FIELDS}
@@ -26,12 +52,14 @@ export const COLLECTION_FIELDS = /* GraphQL */ `
     slug
   }
   productVariantCount
+  ${SEO_FIELDS}
   translations {
     id
     languageCode
     name
     slug
     description
+    ${TRANSLATION_SEO_FIELDS}
   }
 `;
 export const COLLECTIONS_QUERY = /* GraphQL */ `
@@ -44,7 +72,19 @@ export const COLLECTIONS_QUERY = /* GraphQL */ `
 `;
 export const COLLECTION_QUERY = /* GraphQL */ `
   query CatalogCollection($id: ID!) {
-    collection(id: $id) { ${COLLECTION_FIELDS} }
+    collection(id: $id) {
+      ${COLLECTION_FIELDS}
+      parent {
+        id
+        name
+      }
+      children {
+        id
+        name
+        slug
+        position
+      }
+    }
   }
 `;
 export const CREATE_COLLECTION_MUTATION = /* GraphQL */ `
@@ -67,25 +107,216 @@ export const MOVE_COLLECTION_MUTATION = /* GraphQL */ `
     moveCollection(input: $input) { ${COLLECTION_FIELDS} }
   }
 `;
+export const COLLECTION_FILTER_DEFINITIONS_QUERY = /* GraphQL */ `
+  query CatalogCollectionFilterDefinitions {
+    collectionFilters {
+      code
+      description
+      args {
+        name
+        type
+        list
+        required
+        defaultValue
+        label
+        description
+        ui
+      }
+    }
+  }
+`;
+/**
+ * The preview's price is `storePrice` (null for a variant the store has no price for), never
+ * core's `price` / `priceWithTax` / `currencyCode`, which raise "No price information was
+ * found…" for such a variant and, being non-null, empty the whole preview (#1504).
+ */
+export const PREVIEW_COLLECTION_VARIANTS_QUERY = /* GraphQL */ `
+  query CatalogPreviewCollectionVariants(
+    $input: PreviewCollectionVariantsInput!
+    $options: ProductVariantListOptions
+  ) {
+    previewCollectionVariants(input: $input, options: $options) {
+      items {
+        id
+        name
+        sku
+        storePrice {
+          price
+          priceWithTax
+          currencyCode
+        }
+        product {
+          id
+          name
+          featuredAsset { ${ASSET_REF_FIELDS} }
+        }
+      }
+      totalItems
+    }
+  }
+`;
+const COLLECTION_SORT_FIELDS = [
+    'position',
+    'name',
+    'createdAt',
+    'updatedAt',
+    'id',
+];
+function toPreviewVariant(wire) {
+    const { featuredAsset, ...product } = wire.product;
+    return {
+        ...wire,
+        product: { ...product, featuredAsset: featuredAsset ? toAssetRef(featuredAsset) : null },
+    };
+}
+function toSeo(wire) {
+    return {
+        isRoutable: wire?.isRoutable ?? null,
+        isCanonical: wire?.isCanonical ?? null,
+        noindex: wire?.noindex ?? null,
+        nofollow: wire?.nofollow ?? null,
+        metaRobotsMaxImagePreview: wire?.metaRobotsMaxImagePreview ?? null,
+        socialImageId: wire?.socialImageId ?? null,
+        socialOgType: wire?.socialOgType ?? null,
+        twitterCardType: wire?.twitterCardType ?? null,
+    };
+}
+function toTranslationSeo(wire) {
+    return {
+        seoTitle: wire?.seoTitle ?? null,
+        seoDescription: wire?.seoDescription ?? null,
+        canonicalUrl: wire?.canonicalUrl ?? null,
+        socialTitle: wire?.socialTitle ?? null,
+        socialDescription: wire?.socialDescription ?? null,
+        socialImageAlt: wire?.socialImageAlt ?? null,
+    };
+}
+function toCollection(wire) {
+    const { customFields, translations, featuredAsset, assets, ...rest } = wire;
+    return {
+        ...rest,
+        featuredAsset: featuredAsset ? toAssetRef(featuredAsset) : null,
+        assets: (assets ?? []).map(toAssetRef),
+        seo: toSeo(customFields),
+        translations: (translations ?? []).map(({ customFields: seo, ...translation }) => ({
+            ...translation,
+            seo: toTranslationSeo(seo),
+        })),
+    };
+}
+/** `seo` goes on the wire as the engine's `customFields`, only the keys the caller named. */
+function toWireTranslation(translation) {
+    const { seo, ...rest } = translation;
+    return seo === undefined ? rest : { ...rest, customFields: { ...seo } };
+}
+function toWireInput(input) {
+    const { seo, translations, ...rest } = input;
+    return {
+        ...rest,
+        ...(translations === undefined ? {} : { translations: translations.map(toWireTranslation) }),
+        ...(seo === undefined ? {} : { customFields: { ...seo } }),
+    };
+}
+function invalidSort(sort) {
+    return new ValidationError({
+        code: 'INVALID_COLLECTION_SORT',
+        message: `sort must name one of ${COLLECTION_SORT_FIELDS.join(', ')} and the direction ASC or DESC; got ${JSON.stringify(sort)}. Nothing was sent.`,
+        status: 400,
+        service: 'vendure',
+    });
+}
+function listOptionsOf(options) {
+    const filter = {};
+    if (options?.parentId !== undefined)
+        filter.parentId = { eq: options.parentId };
+    if (options?.name !== undefined)
+        filter.name = { contains: options.name };
+    if (options?.ids !== undefined)
+        filter.id = { in: [...options.ids] };
+    const sort = options?.sort;
+    if (sort !== undefined &&
+        (!COLLECTION_SORT_FIELDS.includes(sort.field) ||
+            (sort.direction !== 'ASC' && sort.direction !== 'DESC'))) {
+        throw invalidSort(sort);
+    }
+    return {
+        ...(options?.topLevelOnly === true ? { topLevelOnly: true } : {}),
+        ...(Object.keys(filter).length > 0 ? { filter } : {}),
+        ...(sort === undefined ? {} : { sort: { [sort.field]: sort.direction } }),
+    };
+}
+function invalidSearch(message) {
+    return new ValidationError({
+        code: 'SEARCH_INPUT_INVALID',
+        message: `${message} Nothing was sent.`,
+        status: 400,
+        service: 'vendure',
+    });
+}
 export function createCollectionsModule(transport) {
+    const write = async (document, field, variables, options) => toCollection(await fieldOf(transport, document, field, variables, options));
+    const list = async (options) => {
+        const listOptions = listOptionsOf(options);
+        if (options?.ids !== undefined && options.ids.length === 0) {
+            return pageFromVendureList({ items: [], totalItems: 0 }, 0, options.limit ?? DEFAULT_PAGE_SIZE, () => Promise.reject(new Error('an empty page has no next page')));
+        }
+        return vendureListPage(transport, COLLECTIONS_QUERY, 'collections', (skip, take) => ({ options: { skip, take, ...listOptions } }), options, toCollection);
+    };
     return {
-        list: (options) => {
-            const filter = {};
-            if (options?.parentId !== undefined)
-                filter.parentId = { eq: options.parentId };
-            if (options?.name !== undefined)
-                filter.name = { contains: options.name };
-            return vendureListPage(transport, COLLECTIONS_QUERY, 'collections', (skip, take) => ({
-                options: { skip, take, ...(Object.keys(filter).length > 0 ? { filter } : {}) },
-            }), options);
+        list,
+        async get(id, options) {
+            const collection = await fieldOf(transport, COLLECTION_QUERY, 'collection', { id }, options);
+            return collection ? toCollection(collection) : null;
         },
-        get: (id, options) => fieldOf(transport, COLLECTION_QUERY, 'collection', { id }, options),
-        create: (input, options) => fieldOf(transport, CREATE_COLLECTION_MUTATION, 'createCollection', { input }, options),
-        update: (input, options) => fieldOf(transport, UPDATE_COLLECTION_MUTATION, 'updateCollection', { input }, options),
+        async search(term, options = {}) {
+            const { take = DEFAULT_PAGE_SIZE, skip = 0, ...call } = options;
+            if (!Number.isInteger(take) || take < 1 || take > MAX_COLLECTION_SEARCH_TAKE) {
+                throw invalidSearch(`take must be a whole number from 1 to ${String(MAX_COLLECTION_SEARCH_TAKE)}; got ${String(take)}.`);
+            }
+            if (!Number.isInteger(skip) || skip < 0) {
+                throw invalidSearch(`skip must be a whole number from 0; got ${String(skip)}.`);
+            }
+            const hits = await createSearchModule(transport).index('collections', { term, take, skip }, call);
+            const ids = [...new Set(hits.items.map((hit) => hit.id))];
+            if (ids.length === 0)
+                return { items: [], total: hits.total };
+            // The index says which and in what order; the rows are the engine's, read in the store the
+            // call acts on, so a collection the store no longer holds is not answered.
+            const page = await list({ ...call, ids, limit: ids.length });
+            const byId = new Map(page.items.map((collection) => [collection.id, collection]));
+            return {
+                items: ids.flatMap((id) => {
+                    const collection = byId.get(id);
+                    return collection ? [collection] : [];
+                }),
+                total: hits.total,
+            };
+        },
+        create: (input, options) => write(CREATE_COLLECTION_MUTATION, 'createCollection', { input: toWireInput(input) }, options),
+        update: (input, options) => write(UPDATE_COLLECTION_MUTATION, 'updateCollection', { input: toWireInput(input) }, options),
         async delete(id, options) {
             const response = await fieldOf(transport, DELETE_COLLECTION_MUTATION, 'deleteCollection', { id }, options);
             assertDeleted('COLLECTION_NOT_DELETED', [response]);
         },
-        move: (collectionId, parentId, index, options) => fieldOf(transport, MOVE_COLLECTION_MUTATION, 'moveCollection', { input: { collectionId, parentId, index } }, options),
+        move: (collectionId, parentId, index, options) => write(MOVE_COLLECTION_MUTATION, 'moveCollection', { input: { collectionId, parentId, index } }, options),
+        filterDefinitions: (options) => fieldOf(transport, COLLECTION_FILTER_DEFINITIONS_QUERY, 'collectionFilters', {}, options),
+        previewVariants(input, options = {}) {
+            const { term: rawTerm, ...listOptions } = options;
+            const term = rawTerm?.trim() ?? '';
+            const filter = term === ''
+                ? {}
+                : {
+                    filter: { name: { contains: term }, sku: { contains: term } },
+                    filterOperator: 'OR',
+                };
+            return vendureListPage(transport, PREVIEW_COLLECTION_VARIANTS_QUERY, 'previewCollectionVariants', (skip, take) => ({
+                input: {
+                    filters: input.filters,
+                    inheritFilters: input.inheritFilters,
+                    ...(input.parentId === undefined ? {} : { parentId: input.parentId }),
+                },
+                options: { skip, take, ...filter },
+            }), listOptions, toPreviewVariant);
+        },
     };
 }

package/dist/catalog/index.d.ts

@@ -6,12 +6,15 @@ import { type FacetsModule } from './facets.js';
 import { type OptionsModule } from './options.js';
 import { type ProductsModule } from './products.js';
 import { type ContentFacetSyncResult, type PropertiesModule } from './properties.js';
+import { type RecommendationsModule } from './recommendations.js';
+import { type ReviewsModule } from './reviews.js';
 import { type VariantsModule } from './variants.js';
 import { type VisibilityModule } from './visibility.js';
 /**
  * The catalogue (spec §9.2 `catalog`): products, variants, options, facets,
- * collections, assets, storefront visibility and product properties — one
- * resource per namespace, over the Admin API the dashboard itself uses.
+ * collections, assets, storefront visibility, product properties, product
+ * recommendations and product reviews — one resource per namespace, over the Admin API the
+ * dashboard itself uses.
  *
  * **Per-resource, not per-intent.** Saving a product form is several calls
  * here (the product, its variants, its properties, its collections), and they
@@ -70,6 +73,10 @@ export interface CatalogModule {
     assets: AssetsModule;
     visibility: VisibilityModule;
     properties: PropertiesModule;
+    /** Recommendation groups, their rules and the products picked per product (W10-13). */
+    recommendations: RecommendationsModule;
+    /** Product reviews: moderation, the store's replies, statistics, review attributes (W10-117). */
+    reviews: ReviewsModule;
     /**
      * "Sync filter values" for one filterable `content_item` or `product` property, done by the
      * engine (headless spec §7 `catalog.syncContentFacets`, by property, the unit the merchant syncs).

package/dist/catalog/index.js

@@ -4,6 +4,8 @@ import { createFacetsModule } from './facets.js';
 import { createOptionsModule } from './options.js';
 import { createProductsModule } from './products.js';
 import { createPropertiesModule, syncContentFacets, } from './properties.js';
+import { createRecommendationsModule } from './recommendations.js';
+import { createReviewsModule } from './reviews.js';
 import { createVariantsModule } from './variants.js';
 import { createVisibilityModule } from './visibility.js';
 export function createCatalogModule(transport) {
@@ -16,6 +18,8 @@ export function createCatalogModule(transport) {
         assets: createAssetsModule(transport),
         visibility: createVisibilityModule(transport),
         properties: createPropertiesModule(transport),
+        recommendations: createRecommendationsModule(transport),
+        reviews: createReviewsModule(transport),
         syncContentFacets: (propertyId, options) => syncContentFacets(transport, propertyId, options),
     };
 }