@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/catalog/recommendations.d.ts

@@ -0,0 +1,261 @@
+/**
+ * Product recommendations (headless spec §9.2 `catalog`: "recommendations"; W10-13): the store's
+ * recommendation groups ("Customers also bought", "Complete the look"), what each one draws its
+ * products from, and the products hand-picked per product for a manual group.
+ *
+ * - **A `DYNAMIC` group's entries are its rules**, read in `position` order: one named product
+ *   (`PRODUCT`), the products of a collection (`COLLECTION`) or with a facet value
+ *   (`FACET_VALUE`), or the viewed product's own collections (`SAME_COLLECTION`) or properties
+ *   (`SAME_PROPERTIES`). The storefront fills the group up to `maxItems` from the first entry on,
+ *   never with the viewed product, a disabled product or one the store hides from the shopper.
+ * - **A `MANUAL` group has no entries**: its products are picked per viewed product
+ *   (`manual.set`), and the storefront shows them in the order picked. A group's mode is chosen
+ *   when it is created and never changes.
+ * - **A disabled group** (`enabled: false`) is kept but never shown on the storefront.
+ * - **Positions** are integers; a group or entry created without one goes after the last.
+ *   `reorder` rewrites them as `0, 1, 2…` in the order given.
+ *
+ * Permissions: reads need `ReadCatalog`, writes `UpdateCatalog`. Every row is the store's own: a
+ * group or entry of another store is never answered and never changed (a read answers `null` or
+ * leaves it out; a write refuses it as unknown), and a rule only ever draws from the store's own
+ * products, collections and facet values.
+ *
+ * Refusals, GraphQL errors mapped by `core`. An unknown id and another store's get the same answer,
+ * so none tells whether another store holds the row:
+ * - `ENTITY_NOT_FOUND` → `NotFoundError` (404): a group or entry the store does not have, and the
+ *   viewed product of `manual.set` when the store does not hold it.
+ * - `RECOMMENDATION_SOURCE_NOT_FOUND` → `NotFoundError` (404): a rule's `sourceId` that is not a
+ *   product, collection or facet value of the store (`entries.create`, `entries.update`).
+ * - `RECOMMENDATION_TARGET_NOT_FOUND` → `NotFoundError` (404): `manual.set` picks the store does
+ *   not hold, each named in the message and in `details` (`field` `/targetProductIds/<index>`).
+ * - `RECOMMENDATION_GROUP_SLUG_TAKEN` → `ConflictError` (409): another of the store's groups holds
+ *   the slug, also when two writes race for one free slug.
+ * - `USER_INPUT_ERROR` → `ValidationError` (400), in the engine's words: a rule that does not fit
+ *   its group or its type (a `MANUAL` group, a `sourceId` missing or sent where none goes), picks
+ *   in a `DYNAMIC` group.
+ * - `FORBIDDEN` → `PermissionDeniedError` (403) without the permission.
+ *
+ * An id that is not a uuid (any id argument, a `sourceId` and each pick included) is refused
+ * before all of these with core's `ENTITY_NOT_FOUND` (`NotFoundError`, 404, no `details`), so
+ * branch on the class for not-found and on the code only to tell which row is missing.
+ *
+ * A platform release older than these codes answers each not-found and a taken slug as
+ * `USER_INPUT_ERROR` (400) in its own words ("Recommendation group not found"), a slug lost in a
+ * race as `DUPLICATE_RECORD`, and takes another store's collection or facet value as a rule's
+ * source.
+ *
+ * No release gate: every operation here is served by every platform release this SDK supports.
+ * No method deduplicates on `idempotencyKey`: repeating a `create` makes a second row.
+ */
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** What a `DYNAMIC` group's entry draws its products from. */
+export type RecommendationSourceType = 'PRODUCT' | 'COLLECTION' | 'FACET_VALUE' | 'SAME_COLLECTION' | 'SAME_PROPERTIES';
+/** `DYNAMIC`: rules (entries). `MANUAL`: products picked per viewed product (`manual.set`). */
+export type RecommendationGroupMode = 'DYNAMIC' | 'MANUAL';
+/** The source types whose entry names a row (`sourceId`); the others must name none. */
+export declare const RECOMMENDATION_SOURCE_TYPES_WITH_ID: readonly RecommendationSourceType[];
+/** One rule of a `DYNAMIC` group. */
+export interface RecommendationEntry {
+    id: string;
+    groupId: string;
+    sourceType: RecommendationSourceType;
+    /**
+     * The product, collection or facet value for `PRODUCT`, `COLLECTION` and `FACET_VALUE`; `null`
+     * for `SAME_COLLECTION` and `SAME_PROPERTIES`. Always a row of this store when it was written:
+     * `entries.create` and `entries.update` refuse any other (`RECOMMENDATION_SOURCE_NOT_FOUND`). A
+     * row deleted or taken out of the store since adds nothing, and the storefront never draws from
+     * another store's collection or facet value, a rule stored before the refusal included. A deleted
+     * product's `PRODUCT` entries are removed with it.
+     */
+    sourceId: string | null;
+    position: number;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    /** ISO-8601 UTC. */
+    updatedAt: string;
+}
+/** A group without its entries, as `manual.get` and `manual.set` answer it. */
+export interface RecommendationGroupSummary {
+    id: string;
+    name: string;
+    /** Unique within the store; the storefront asks for one group by it. */
+    slug: string;
+    description: string | null;
+    /** The most products the storefront shows for this group. */
+    maxItems: number;
+    position: number;
+    enabled: boolean;
+    mode: RecommendationGroupMode;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    /** ISO-8601 UTC. */
+    updatedAt: string;
+}
+export interface RecommendationGroup extends RecommendationGroupSummary {
+    /** In `position` order (ties: the older first). Always empty on a `MANUAL` group. */
+    entries: RecommendationEntry[];
+}
+/** One `MANUAL` group and the products picked in it for one viewed product. */
+export interface ProductManualRecommendations {
+    group: RecommendationGroupSummary;
+    /** In the order picked; empty when none are. */
+    productIds: string[];
+}
+export interface CreateRecommendationGroupInput {
+    name: string;
+    /** Defaults to the name, lower-cased, every run of other characters than `a-z0-9` a `-`. */
+    slug?: string;
+    description?: string;
+    /** Defaults to 10. The engine sets no bounds. */
+    maxItems?: number;
+    /** Defaults to after the store's last group. */
+    position?: number;
+    /** Defaults to true. */
+    enabled?: boolean;
+    /** Defaults to `DYNAMIC`; never changes afterwards. */
+    mode?: RecommendationGroupMode;
+}
+/** Only the fields named change; `description: null` clears it. */
+export interface UpdateRecommendationGroupInput {
+    name?: string;
+    slug?: string;
+    description?: string | null;
+    maxItems?: number;
+    position?: number;
+    enabled?: boolean;
+}
+export interface CreateRecommendationEntryInput {
+    groupId: string;
+    sourceType: RecommendationSourceType;
+    /** Required for `PRODUCT`, `COLLECTION` and `FACET_VALUE`; refused for the other two. */
+    sourceId?: string;
+    /** Defaults to after the group's last entry. */
+    position?: number;
+}
+/** Only the fields named change; `sourceId: null` clears it (for a `SAME_*` source type). */
+export interface UpdateRecommendationEntryInput {
+    sourceType?: RecommendationSourceType;
+    sourceId?: string | null;
+    position?: number;
+}
+export interface RecommendationsModule {
+    groups: {
+        /**
+         * Every group of the store, in `position` order (ties: the older first), each with its
+         * entries. The engine answers them all at once; there are no pages.
+         *
+         * @effect read
+         */
+        list(options?: Call): Promise<RecommendationGroup[]>;
+        /**
+         * One group with its entries; `null` when the store has no group with that id.
+         *
+         * @effect read
+         */
+        get(id: string, options?: Call): Promise<RecommendationGroup | null>;
+        /**
+         * Refused (`RECOMMENDATION_GROUP_SLUG_TAKEN`) when the store already has a group with that
+         * slug, the defaulted one included.
+         *
+         * @effect write
+         */
+        create(input: CreateRecommendationGroupInput, options?: Call): Promise<RecommendationGroup>;
+        /**
+         * Refused: a group the store does not have (`ENTITY_NOT_FOUND`), a slug another of its groups
+         * holds (`RECOMMENDATION_GROUP_SLUG_TAKEN`).
+         *
+         * @effect write
+         */
+        update(id: string, input: UpdateRecommendationGroupInput, options?: Call): Promise<RecommendationGroup>;
+        /**
+         * Deletes the group, its entries and every product's picks in it. Refused
+         * (`ENTITY_NOT_FOUND`) for a group the store does not have.
+         *
+         * @effect destructive
+         */
+        delete(id: string, options?: Call): Promise<void>;
+        /**
+         * Gives the named groups the positions `0, 1, 2…` in the order given, and answers every group
+         * as `list` does. An id the store does not hold is skipped without a word; a group left out
+         * keeps its position, which may then equal a named one's: name them all.
+         *
+         * @effect write
+         */
+        reorder(ids: string[], options?: Call): Promise<RecommendationGroup[]>;
+    };
+    /** The rules of `DYNAMIC` groups. */
+    entries: {
+        /**
+         * Refused: a group the store does not have (`ENTITY_NOT_FOUND`); a `sourceId` that is not a
+         * product, collection or facet value of the store (`RECOMMENDATION_SOURCE_NOT_FOUND`: another
+         * store's is refused like an unknown id); a `MANUAL` group, or a `sourceId` missing for
+         * `PRODUCT` / `COLLECTION` / `FACET_VALUE` or sent for `SAME_COLLECTION` / `SAME_PROPERTIES`
+         * (`USER_INPUT_ERROR`).
+         *
+         * @effect write
+         */
+        create(input: CreateRecommendationEntryInput, options?: Call): Promise<RecommendationEntry>;
+        /**
+         * Refused: an entry the store does not have (`ENTITY_NOT_FOUND`); a source type and
+         * `sourceId` that do not go together once the change is applied (`USER_INPUT_ERROR`); a
+         * change of either that leaves the rule naming no row of the store
+         * (`RECOMMENDATION_SOURCE_NOT_FOUND`). A change of `position` alone is not judged.
+         *
+         * @effect write
+         */
+        update(id: string, input: UpdateRecommendationEntryInput, options?: Call): Promise<RecommendationEntry>;
+        /**
+         * Refused (`ENTITY_NOT_FOUND`) for an entry the store does not have.
+         *
+         * @effect destructive
+         */
+        delete(id: string, options?: Call): Promise<void>;
+        /**
+         * Gives the group's named entries the positions `0, 1, 2…` in the order given, and answers
+         * the group's entries in `position` order. An id that is not one of THIS group's entries is
+         * skipped without a word (another group's entry never moves); an entry left out keeps its
+         * position. Refused (`ENTITY_NOT_FOUND`) for a group the store does not have.
+         *
+         * @effect write
+         */
+        reorder(groupId: string, ids: string[], options?: Call): Promise<RecommendationEntry[]>;
+    };
+    /** The products picked per viewed product in `MANUAL` groups (the product page's card). */
+    manual: {
+        /**
+         * Every `MANUAL` group of the store, in `position` order, each with the products picked for
+         * `productId`. A product with no picks (or none of this store) answers every group with an
+         * empty `productIds`; a store with no manual group answers `[]`.
+         *
+         * @effect read
+         */
+        get(productId: string, options?: Call): Promise<ProductManualRecommendations[]>;
+        /**
+         * Replaces the products picked for `productId` in one `MANUAL` group, in the order given:
+         * `[]` clears them. The product itself and repeats are dropped (the first one kept). One
+         * write: refused, nothing changes.
+         *
+         * Refused: a group the store does not have, or `productId` not a product of this store
+         * (`ENTITY_NOT_FOUND`); a picked product that is not (`RECOMMENDATION_TARGET_NOT_FOUND`,
+         * naming each, `details` pointing at where it was sent); a `DYNAMIC` group
+         * (`USER_INPUT_ERROR`).
+         *
+         * @effect write
+         */
+        set(productId: string, groupId: string, productIds: string[], options?: Call): Promise<RecommendationGroupSummary>;
+    };
+}
+export declare const RECOMMENDATION_GROUPS_QUERY = "\n  query CatalogRecommendationGroups {\n    recommendationGroups { \n  \n  id\n  name\n  slug\n  description\n  maxItems\n  position\n  enabled\n  mode\n  createdAt\n  updatedAt\n\n  entries { \n  id\n  groupId\n  sourceType\n  sourceId\n  position\n  createdAt\n  updatedAt\n }\n }\n  }\n";
+export declare const RECOMMENDATION_GROUP_QUERY = "\n  query CatalogRecommendationGroup($id: ID!) {\n    recommendationGroup(id: $id) { \n  \n  id\n  name\n  slug\n  description\n  maxItems\n  position\n  enabled\n  mode\n  createdAt\n  updatedAt\n\n  entries { \n  id\n  groupId\n  sourceType\n  sourceId\n  position\n  createdAt\n  updatedAt\n }\n }\n  }\n";
+export declare const CREATE_RECOMMENDATION_GROUP_MUTATION = "\n  mutation CatalogCreateRecommendationGroup($input: CreateRecommendationGroupInput!) {\n    createRecommendationGroup(input: $input) { \n  \n  id\n  name\n  slug\n  description\n  maxItems\n  position\n  enabled\n  mode\n  createdAt\n  updatedAt\n\n  entries { \n  id\n  groupId\n  sourceType\n  sourceId\n  position\n  createdAt\n  updatedAt\n }\n }\n  }\n";
+export declare const UPDATE_RECOMMENDATION_GROUP_MUTATION = "\n  mutation CatalogUpdateRecommendationGroup($id: ID!, $input: UpdateRecommendationGroupInput!) {\n    updateRecommendationGroup(id: $id, input: $input) { \n  \n  id\n  name\n  slug\n  description\n  maxItems\n  position\n  enabled\n  mode\n  createdAt\n  updatedAt\n\n  entries { \n  id\n  groupId\n  sourceType\n  sourceId\n  position\n  createdAt\n  updatedAt\n }\n }\n  }\n";
+export declare const DELETE_RECOMMENDATION_GROUP_MUTATION = "\n  mutation CatalogDeleteRecommendationGroup($id: ID!) {\n    deleteRecommendationGroup(id: $id) { \n  result\n  message\n }\n  }\n";
+export declare const REORDER_RECOMMENDATION_GROUPS_MUTATION = "\n  mutation CatalogReorderRecommendationGroups($ids: [ID!]!) {\n    reorderRecommendationGroups(ids: $ids) { \n  \n  id\n  name\n  slug\n  description\n  maxItems\n  position\n  enabled\n  mode\n  createdAt\n  updatedAt\n\n  entries { \n  id\n  groupId\n  sourceType\n  sourceId\n  position\n  createdAt\n  updatedAt\n }\n }\n  }\n";
+export declare const CREATE_RECOMMENDATION_ENTRY_MUTATION = "\n  mutation CatalogCreateRecommendationEntry($input: CreateRecommendationEntryInput!) {\n    createRecommendationEntry(input: $input) { \n  id\n  groupId\n  sourceType\n  sourceId\n  position\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const UPDATE_RECOMMENDATION_ENTRY_MUTATION = "\n  mutation CatalogUpdateRecommendationEntry($id: ID!, $input: UpdateRecommendationEntryInput!) {\n    updateRecommendationEntry(id: $id, input: $input) { \n  id\n  groupId\n  sourceType\n  sourceId\n  position\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const DELETE_RECOMMENDATION_ENTRY_MUTATION = "\n  mutation CatalogDeleteRecommendationEntry($id: ID!) {\n    deleteRecommendationEntry(id: $id) { \n  result\n  message\n }\n  }\n";
+export declare const REORDER_RECOMMENDATION_ENTRIES_MUTATION = "\n  mutation CatalogReorderRecommendationEntries($groupId: ID!, $ids: [ID!]!) {\n    reorderRecommendationEntries(groupId: $groupId, ids: $ids) { \n  id\n  groupId\n  sourceType\n  sourceId\n  position\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const PRODUCT_MANUAL_RECOMMENDATIONS_QUERY = "\n  query CatalogProductManualRecommendations($productId: ID!) {\n    productManualRecommendations(productId: $productId) {\n      group { \n  id\n  name\n  slug\n  description\n  maxItems\n  position\n  enabled\n  mode\n  createdAt\n  updatedAt\n }\n      productIds\n    }\n  }\n";
+export declare const SET_PRODUCT_MANUAL_RECOMMENDATIONS_MUTATION = "\n  mutation CatalogSetProductManualRecommendations(\n    $productId: ID!\n    $groupId: ID!\n    $targetProductIds: [ID!]!\n  ) {\n    setProductManualRecommendations(\n      productId: $productId\n      groupId: $groupId\n      targetProductIds: $targetProductIds\n    ) { \n  id\n  name\n  slug\n  description\n  maxItems\n  position\n  enabled\n  mode\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare function createRecommendationsModule(transport: Transport): RecommendationsModule;

package/dist/catalog/recommendations.js

@@ -0,0 +1,145 @@
+import { assertDeleted, DELETION_FIELDS, fieldOf } from './types.js';
+/** The source types whose entry names a row (`sourceId`); the others must name none. */
+export const RECOMMENDATION_SOURCE_TYPES_WITH_ID = [
+    'PRODUCT',
+    'COLLECTION',
+    'FACET_VALUE',
+];
+const ENTRY_FIELDS = /* GraphQL */ `
+  id
+  groupId
+  sourceType
+  sourceId
+  position
+  createdAt
+  updatedAt
+`;
+const GROUP_SUMMARY_FIELDS = /* GraphQL */ `
+  id
+  name
+  slug
+  description
+  maxItems
+  position
+  enabled
+  mode
+  createdAt
+  updatedAt
+`;
+const GROUP_FIELDS = /* GraphQL */ `
+  ${GROUP_SUMMARY_FIELDS}
+  entries { ${ENTRY_FIELDS} }
+`;
+export const RECOMMENDATION_GROUPS_QUERY = /* GraphQL */ `
+  query CatalogRecommendationGroups {
+    recommendationGroups { ${GROUP_FIELDS} }
+  }
+`;
+export const RECOMMENDATION_GROUP_QUERY = /* GraphQL */ `
+  query CatalogRecommendationGroup($id: ID!) {
+    recommendationGroup(id: $id) { ${GROUP_FIELDS} }
+  }
+`;
+export const CREATE_RECOMMENDATION_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogCreateRecommendationGroup($input: CreateRecommendationGroupInput!) {
+    createRecommendationGroup(input: $input) { ${GROUP_FIELDS} }
+  }
+`;
+export const UPDATE_RECOMMENDATION_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogUpdateRecommendationGroup($id: ID!, $input: UpdateRecommendationGroupInput!) {
+    updateRecommendationGroup(id: $id, input: $input) { ${GROUP_FIELDS} }
+  }
+`;
+export const DELETE_RECOMMENDATION_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogDeleteRecommendationGroup($id: ID!) {
+    deleteRecommendationGroup(id: $id) { ${DELETION_FIELDS} }
+  }
+`;
+export const REORDER_RECOMMENDATION_GROUPS_MUTATION = /* GraphQL */ `
+  mutation CatalogReorderRecommendationGroups($ids: [ID!]!) {
+    reorderRecommendationGroups(ids: $ids) { ${GROUP_FIELDS} }
+  }
+`;
+export const CREATE_RECOMMENDATION_ENTRY_MUTATION = /* GraphQL */ `
+  mutation CatalogCreateRecommendationEntry($input: CreateRecommendationEntryInput!) {
+    createRecommendationEntry(input: $input) { ${ENTRY_FIELDS} }
+  }
+`;
+export const UPDATE_RECOMMENDATION_ENTRY_MUTATION = /* GraphQL */ `
+  mutation CatalogUpdateRecommendationEntry($id: ID!, $input: UpdateRecommendationEntryInput!) {
+    updateRecommendationEntry(id: $id, input: $input) { ${ENTRY_FIELDS} }
+  }
+`;
+export const DELETE_RECOMMENDATION_ENTRY_MUTATION = /* GraphQL */ `
+  mutation CatalogDeleteRecommendationEntry($id: ID!) {
+    deleteRecommendationEntry(id: $id) { ${DELETION_FIELDS} }
+  }
+`;
+export const REORDER_RECOMMENDATION_ENTRIES_MUTATION = /* GraphQL */ `
+  mutation CatalogReorderRecommendationEntries($groupId: ID!, $ids: [ID!]!) {
+    reorderRecommendationEntries(groupId: $groupId, ids: $ids) { ${ENTRY_FIELDS} }
+  }
+`;
+// The engine does not load `entries` for these groups (a MANUAL group has none), and selecting a
+// non-null field it did not load fails the whole read: never add `entries` here.
+export const PRODUCT_MANUAL_RECOMMENDATIONS_QUERY = /* GraphQL */ `
+  query CatalogProductManualRecommendations($productId: ID!) {
+    productManualRecommendations(productId: $productId) {
+      group { ${GROUP_SUMMARY_FIELDS} }
+      productIds
+    }
+  }
+`;
+export const SET_PRODUCT_MANUAL_RECOMMENDATIONS_MUTATION = /* GraphQL */ `
+  mutation CatalogSetProductManualRecommendations(
+    $productId: ID!
+    $groupId: ID!
+    $targetProductIds: [ID!]!
+  ) {
+    setProductManualRecommendations(
+      productId: $productId
+      groupId: $groupId
+      targetProductIds: $targetProductIds
+    ) { ${GROUP_SUMMARY_FIELDS} }
+  }
+`;
+/** Entries in `position` order, the older first on a tie, as the engine's own entry reads sort. */
+function byPosition(entries) {
+    return [...entries].sort((a, b) => a.position - b.position || a.createdAt.localeCompare(b.createdAt));
+}
+// The engine's group list loads `entries` without an order; only its one-group read sorts them.
+function withSortedEntries(group) {
+    return { ...group, entries: byPosition(group.entries) };
+}
+export function createRecommendationsModule(transport) {
+    const call = (document, field, variables, options) => fieldOf(transport, document, field, variables, options);
+    return {
+        groups: {
+            list: async (options) => (await call(RECOMMENDATION_GROUPS_QUERY, 'recommendationGroups', {}, options)).map(withSortedEntries),
+            async get(id, options) {
+                const group = await call(RECOMMENDATION_GROUP_QUERY, 'recommendationGroup', { id }, options);
+                return group === null ? null : withSortedEntries(group);
+            },
+            create: async (input, options) => withSortedEntries(await call(CREATE_RECOMMENDATION_GROUP_MUTATION, 'createRecommendationGroup', { input }, options)),
+            update: async (id, input, options) => withSortedEntries(await call(UPDATE_RECOMMENDATION_GROUP_MUTATION, 'updateRecommendationGroup', { id, input }, options)),
+            async delete(id, options) {
+                const response = await call(DELETE_RECOMMENDATION_GROUP_MUTATION, 'deleteRecommendationGroup', { id }, options);
+                assertDeleted('RECOMMENDATION_GROUP_NOT_DELETED', [response]);
+            },
+            reorder: async (ids, options) => (await call(REORDER_RECOMMENDATION_GROUPS_MUTATION, 'reorderRecommendationGroups', { ids }, options)).map(withSortedEntries),
+        },
+        entries: {
+            create: (input, options) => call(CREATE_RECOMMENDATION_ENTRY_MUTATION, 'createRecommendationEntry', { input }, options),
+            update: (id, input, options) => call(UPDATE_RECOMMENDATION_ENTRY_MUTATION, 'updateRecommendationEntry', { id, input }, options),
+            async delete(id, options) {
+                const response = await call(DELETE_RECOMMENDATION_ENTRY_MUTATION, 'deleteRecommendationEntry', { id }, options);
+                assertDeleted('RECOMMENDATION_ENTRY_NOT_DELETED', [response]);
+            },
+            reorder: (groupId, ids, options) => call(REORDER_RECOMMENDATION_ENTRIES_MUTATION, 'reorderRecommendationEntries', { groupId, ids }, options),
+        },
+        manual: {
+            get: (productId, options) => call(PRODUCT_MANUAL_RECOMMENDATIONS_QUERY, 'productManualRecommendations', { productId }, options),
+            set: (productId, groupId, productIds, options) => call(SET_PRODUCT_MANUAL_RECOMMENDATIONS_MUTATION, 'setProductManualRecommendations', { productId, groupId, targetProductIds: productIds }, options),
+        },
+    };
+}