@unchainedshop/api 4.0.0-rc.5 → 4.0.0-rc.7

package/src/mcp/tools/product/updateProductVariationTextsHandler.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { ProductVariationNotFoundError } from '../../../errors.js';
+
+export const ProductVariationTextInputSchema = z.object({
+  locale: z.string().min(1).describe('Locale code (e.g., "en", "de")'),
+  title: z.string().optional().describe('Title of the variation in the given locale'),
+  subtitle: z.string().optional().describe('Subtitle of the variation in the given locale'),
+});
+
+export const UpdateProductVariationTextsSchema = {
+  productVariationId: z.string().min(1).describe('ID of the product variation to update'),
+  productVariationOptionValue: z
+    .string()
+    .optional()
+    .describe('Optional production option value to filter variations'),
+  texts: z
+    .array(ProductVariationTextInputSchema)
+    .min(1)
+    .describe('Localized texts to apply to the variation'),
+};
+
+export const UpdateProductVariationTextsZodSchema = z.object(UpdateProductVariationTextsSchema);
+
+export type UpdateProductVariationTextsParams = z.infer<typeof UpdateProductVariationTextsZodSchema>;
+
+export async function updateProductVariationTextsHandler(
+  context: Context,
+  params: UpdateProductVariationTextsParams,
+) {
+  const { productVariationId, productVariationOptionValue, texts } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler updateProductVariationTextsHandler', { userId, params });
+    const productVariation = await modules.products.variations.findProductVariation({
+      productVariationId,
+    });
+    if (!productVariation) throw new ProductVariationNotFoundError({ productVariationId });
+
+    const updatedTexts = await modules.products.variations.texts.updateVariationTexts(
+      productVariationId,
+      texts as any,
+      productVariationOptionValue,
+    );
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts: updatedTexts, productId: productVariation.productId }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating product warehousing: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/product/variationProductsHandler.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongTypeError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+
+const VariationProductsVectorSchema = z.object({
+  key: z.string().min(1),
+  value: z.string().min(1),
+});
+
+export const VariationProductsSchema = {
+  productId: z.string().min(1),
+  vectors: z.array(VariationProductsVectorSchema).min(1),
+  includeInactive: z.boolean().optional().default(true).describe('Whether to include inactive products'),
+};
+export const VariationProductsZodSchema = z.object(VariationProductsSchema);
+export type VariationProductsParams = z.infer<typeof VariationProductsZodSchema>;
+
+export const variationProductsHandler = async (context: Context, params: VariationProductsParams) => {
+  const { modules, userId } = context;
+  const { productId, vectors, includeInactive } = params;
+
+  try {
+    log('handler variationProductsHandler', { userId, params });
+    const product = await modules.products.findProduct({ productId });
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    if (product.type !== 'CONFIGURABLE_PRODUCT') {
+      throw new ProductWrongTypeError({
+        productId,
+        received: product.type,
+        required: 'CONFIGURABLE_PRODUCT',
+      });
+    }
+
+    const products = await modules.products.proxyProducts(product, vectors as any, {
+      includeInactive,
+    });
+    const normalizedProducts = await Promise.all(
+      products.map(async ({ _id }) => getNormalizedProductDetails(_id, context)),
+    );
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ products: normalizedProducts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error fetching variation products: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+};

package/src/mcp/tools/shopInfoHandler.ts

@@ -5,12 +5,14 @@ export async function shopInfoHandler(context: Context) {
   const { version, userId, loaders, locale, countryCode } = context;
 
   try {
-    log('query shopInfo', { userId });
+    log('handler shopInfoHandler', { userId });
 
     const language = await loaders.languageLoader.load({ isoCode: locale.language });
 
     const country = await loaders.countryLoader.load({ isoCode: countryCode });
-    const defaultLanguageIsoCode = language.isoCode + '-' + country.isoCode;
+    const defaultLanguageIsoCode = language?.isoCode
+      ? `${language.isoCode}${country?.isoCode ? '-' + country.isoCode : ''}`
+      : null;
 
     return {
       content: [

package/src/mcp/utils/getNormalizedProductDetails.ts

@@ -13,11 +13,38 @@ export async function getNormalizedProductDetails(productId: string, context: Co
     locale,
   });
   let variations = [];
+  let bundleItems = [];
   if (product.type === ProductTypes.ConfigurableProduct)
     variations = await context.modules.products.variations.findProductVariations({
       productId: product._id,
     });
 
+  if (product.type === ProductTypes.BundleProduct) {
+    bundleItems = await Promise.all(
+      (product.bundleItems || []).map(async (item) => {
+        const bundleItemProduct = await loaders.productLoader.load({
+          productId: item.productId,
+        });
+        const productMedias = await modules.products.media.findProductMedias({
+          productId: item.productId,
+        });
+        const media = await normalizeMediaUrl(productMedias, context);
+        const texts = await loaders.productTextLoader.load({
+          productId: item.productId,
+          locale,
+        });
+        return {
+          product: {
+            ...bundleItemProduct,
+            media,
+            texts,
+          },
+          ...item,
+        };
+      }),
+    );
+  }
+
   // Get pricing information
   let pricing = null;
   try {
@@ -37,6 +64,7 @@ export async function getNormalizedProductDetails(productId: string, context: Co
     texts,
     media,
     variations,
+    bundleItems,
     pricing,
   };
 }

package/src/resolvers/mutations/filters/createFilter.ts

@@ -2,6 +2,7 @@ import { log } from '@unchainedshop/logger';
 import { Filter } from '@unchainedshop/core-filters';
 import { Context } from '../../../context.js';
 import { FilterDirector, FilterInputText } from '@unchainedshop/core';
+import { DuplicateFilterKeyError } from '../../../errors.js';
 
 export default async function createFilter(
   root: never,
@@ -10,13 +11,17 @@ export default async function createFilter(
 ) {
   const { modules, userId } = context;
   log('mutation createFilter', { userId });
+  try {
+    const newFilter = await modules.filters.create(filter);
 
-  const newFilter = await modules.filters.create(filter);
+    await FilterDirector.invalidateProductIdCache(newFilter, context);
 
-  await FilterDirector.invalidateProductIdCache(newFilter, context);
-
-  if (texts) {
-    await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+    if (texts) {
+      await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+    }
+    return newFilter;
+  } catch (e) {
+    if (e?.message?.includes('duplicate')) throw new DuplicateFilterKeyError({ filter });
+    else throw e;
   }
-  return newFilter;
 }

package/src/resolvers/mutations/products/createProductBundleItem.ts

@@ -2,7 +2,12 @@ import { log } from '@unchainedshop/logger';
 import { ProductTypes } from '@unchainedshop/core-products';
 import { Context } from '../../../context.js';
 import { ProductBundleItem } from '@unchainedshop/core-products';
-import { ProductNotFoundError, InvalidIdError, ProductWrongTypeError } from '../../../errors.js';
+import {
+  ProductNotFoundError,
+  InvalidIdError,
+  ProductWrongTypeError,
+  CyclicProductBundlingNotSupportedError,
+} from '../../../errors.js';
 
 export default async function createProductBundleItem(
   root: never,
@@ -24,8 +29,13 @@ export default async function createProductBundleItem(
       required: ProductTypes.BundleProduct,
     });
 
-  if (!(await modules.products.productExists({ productId: item.productId })))
-    throw new ProductNotFoundError({ productId: item.productId });
+  const itemProduct = await modules.products.findProduct({ productId: item.productId });
+  if (!itemProduct) throw new ProductNotFoundError({ productId: item.productId });
+
+  if (itemProduct._id === product._id)
+    throw new CyclicProductBundlingNotSupportedError({
+      productId: itemProduct._id,
+    });
 
   await modules.products.bundleItems.addBundleItem(productId, item);
 

package/src/resolvers/type/index.ts

@@ -52,6 +52,7 @@ import { ProductVariation } from './product/product-variation-types.js';
 import { ProductVariationAssignment } from './product/product-variation-assignment-types.js';
 import { ProductVariationAssignmentVector } from './product/product-variation-assignment-vector.js';
 import { ProductVariationOption } from './product/product-variation-option-types.js';
+import { ConfigurableOrBundleProduct } from './product/product-configurable-or-bundle-product-types.js';
 import { Quotation } from './quotation-types.js';
 import { Shop } from './shop-types.js';
 import { SimpleProduct } from './product/product-simple-types.js';
@@ -123,6 +124,7 @@ const types = {
   ProductVariationAssignmentVector,
   ProductVariationOption,
   ProductSearchResult,
+  ConfigurableOrBundleProduct,
   Quotation,
   Shop,
   SimpleProduct,

package/src/resolvers/type/product/product-configurable-or-bundle-product-types.ts

@@ -0,0 +1,10 @@
+import { Product as ProductType } from '@unchainedshop/core-products';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { objectInvert } from '@unchainedshop/utils';
+
+export const ConfigurableOrBundleProduct = {
+  __resolveType: (product: ProductType): string => {
+    const invertedProductTypes = objectInvert(ProductTypes);
+    return invertedProductTypes[product.type];
+  },
+};

package/src/resolvers/type/product/product-types.ts

@@ -13,6 +13,10 @@ export const Product = {
     return invertedProductTypes[product.type];
   },
 
+  async proxies(product: ProductType, _: never, context: Context): Promise<ProductType[]> {
+    return context.loaders.productProxiesLoader.load({ productId: product._id });
+  },
+
   async assortmentPaths(
     product: ProductType,
     params: {

package/src/schema/types/product/bundle-product.ts

@@ -1,7 +1,7 @@
 export default [
   /* GraphQL */ `
     """
-    A Bundle product consists of multiple configured products
+    A Bundle product consists of multiple products
     """
     type BundleProduct implements Product @cacheControl(maxAge: 180) {
       _id: ID!
@@ -22,6 +22,7 @@ export default [
       ): [ProductReview!]!
       reviewsCount(queryString: String): Int!
       assortmentPaths: [ProductAssortmentPath!]!
+      proxies: [ConfigurableOrBundleProduct!]!
       siblings(
         assortmentId: ID
         limit: Int = 10

package/src/schema/types/product/configurable-product.ts

@@ -73,6 +73,7 @@ export default [
       media(limit: Int = 10, offset: Int = 0, tags: [LowerCaseString!]): [ProductMedia!]!
       texts(forceLocale: Locale): ProductTexts
       assortmentPaths: [ProductAssortmentPath!]!
+      proxies: [ConfigurableOrBundleProduct!]!
       siblings(
         assortmentId: ID
         limit: Int = 10

package/src/schema/types/product/plan-product.ts

@@ -51,6 +51,7 @@ export default [
         configuration: [ProductConfigurationParameterInput!]
       ): Price @cacheControl(scope: PRIVATE)
       assortmentPaths(forceLocale: Locale): [ProductAssortmentPath!]!
+      proxies: [ConfigurableOrBundleProduct!]!
       siblings(
         assortmentId: ID
         limit: Int = 10

package/src/schema/types/product/product.ts

@@ -71,6 +71,7 @@ export default [
       ): [ProductReview!]!
       reviewsCount(queryString: String): Int!
       assortmentPaths: [ProductAssortmentPath!]!
+      proxies: [ConfigurableOrBundleProduct!]!
       siblings(
         assortmentId: ID
         limit: Int = 10
@@ -132,5 +133,7 @@ export default [
       amount: Int!
       maxQuantity: Int
     }
+
+    union ConfigurableOrBundleProduct = BundleProduct | ConfigurableProduct
   `,
 ];

package/src/schema/types/product/simple-product.ts

@@ -31,6 +31,7 @@ export default [
         referenceDate: Timestamp
       ): [Stock!] @cacheControl(scope: PRIVATE, maxAge: 10)
       assortmentPaths: [ProductAssortmentPath!]!
+      proxies: [ConfigurableOrBundleProduct!]!
       siblings(
         assortmentId: ID
         limit: Int = 10

package/src/schema/types/product/tokenized-product.ts

@@ -42,6 +42,7 @@ export default [
       ): Price @cacheControl(scope: PRIVATE, maxAge: 10)
       simulatedStocks(referenceDate: Timestamp): [Stock!] @cacheControl(scope: PRIVATE, maxAge: 10)
       assortmentPaths(forceLocale: Locale): [ProductAssortmentPath!]!
+      proxies: [ConfigurableOrBundleProduct!]!
       siblings(
         assortmentId: ID
         limit: Int = 10