@unchainedshop/api 4.0.0-rc.4 → 4.0.0-rc.6

package/src/mcp/tools/language/languagesHandler.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { SortDirection } from '@unchainedshop/utils';
+import { log } from '@unchainedshop/logger';
 
 const sortDirectionKeys = Object.keys(SortDirection) as [
   keyof typeof SortDirection,
@@ -8,18 +9,19 @@ const sortDirectionKeys = Object.keys(SortDirection) as [
 ];
 
 export const ListLanguagesSchema = {
-  limit: z.number().int().min(1).max(100).default(50),
-  offset: z.number().int().min(0).default(0),
-  includeInactive: z.boolean().default(false),
-  queryString: z.string().min(1).optional(),
+  limit: z.number().int().min(1).max(100).default(50).describe('Maximum number of languages to return'),
+  offset: z.number().int().min(0).default(0).describe('Number of languages to skip for pagination'),
+  includeInactive: z.boolean().default(false).describe('Whether to include inactive languages'),
+  query_string: z.string().min(1).optional().describe('Optional text search filter'),
   sort: z
     .array(
       z.object({
-        key: z.string().min(1),
-        value: z.enum(sortDirectionKeys).describe("Sort direction, e.g., 'ASC' or 'DESC'"),
+        key: z.string().min(1).describe('Field to sort by'),
+        value: z.enum(sortDirectionKeys).describe("Sort direction, 'ASC' or 'DESC'"),
       }),
     )
-    .optional(),
+    .optional()
+    .describe('Sort configuration'),
 };
 
 export const ListLanguagesZodSchema = z.object(ListLanguagesSchema);
@@ -27,11 +29,14 @@ export const ListLanguagesZodSchema = z.object(ListLanguagesSchema);
 export type ListLanguagesParams = z.infer<typeof ListLanguagesZodSchema>;
 
 export async function languagesHandler(context: Context, params: ListLanguagesParams) {
-  const { sort, ...restParams } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
-    const languages = await modules.languages.findLanguages({ ...restParams, sort: sort as any[] });
+    log(`handler languagesHandler `, {
+      userId,
+      params,
+    });
+    const languages = await modules.languages.findLanguages(params as any);
 
     return {
       content: [

package/src/mcp/tools/language/removeLanguageHandler.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { LanguageNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 export const RemoveLanguageSchema = {
   languageId: z.string().min(1).describe('ID of the language to remove'),
@@ -11,9 +12,13 @@ export type RemoveLanguageParams = z.infer<typeof RemoveLanguageZodSchema>;
 
 export async function removeLanguageHandler(context: Context, params: RemoveLanguageParams) {
   const { languageId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler languagesHandler `, {
+      userId,
+      params,
+    });
     if (!(await modules.languages.languageExists({ languageId })))
       throw new LanguageNotFoundError({ languageId });
 

package/src/mcp/tools/language/updateLanguageHandler.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { LanguageNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 const UpdateLanguageInputSchema = z.object({
   isoCode: z.string().min(2).max(10).describe('Updated ISO code for the language'),
@@ -17,9 +18,13 @@ export type UpdateLanguageParams = z.infer<typeof UpdateLanguageZodSchema>;
 
 export async function updateLanguageHandler(context: Context, params: UpdateLanguageParams) {
   const { languageId, language } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler updateLanguageHandler `, {
+      userId,
+      params,
+    });
     if (!(await modules.languages.languageExists({ languageId })))
       throw new LanguageNotFoundError({ languageId });
 

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

@@ -8,6 +8,7 @@ import {
   ProductWrongTypeError,
 } from '../../../errors.js';
 import { ProductConfiguration, ProductTypes } from '@unchainedshop/core-products';
+import { log } from '@unchainedshop/logger';
 
 const extractVariationMatrix = (variations = []) => {
   const cartesianProduct = (arrays) => {
@@ -36,33 +37,35 @@ const combinationExists = (matrix, combination) => {
   });
 };
 
-// Zod schema for ProductAssignmentVectorInput
 const ProductAssignmentVectorSchema = z.object({
   key: z.string().min(1).describe('Attribute key (e.g., "Color", "Size")'),
   value: z.string().min(1).describe('Attribute value (e.g., "Red", "M")'),
 });
 
 export const AssignProductVariationSchema = {
-  proxyId: z.string().min(1).describe('should be ID of the CONFIGURABLE_PRODUCT (parent) only'),
+  proxyId: z.string().min(1).describe('ID of the CONFIGURABLE_PRODUCT (parent) only'),
   productId: z
     .string()
     .min(1)
-    .describe('ID of the product being assigned. can not be a CONFIGURABLE_PRODUCT product'),
+    .describe('ID of the product being assigned. Cannot be a CONFIGURABLE_PRODUCT product'),
   vectors: z
     .array(ProductAssignmentVectorSchema)
     .min(1)
-    .describe('Combination of attributes uniquely identifying the variant'),
+    .describe(
+      'Provide one option for **each** variation of the parent product (e.g., Color and Size). if it is not complete request the user to add all options or offer to create it. Do not call this tool unless all variation options have been selected. Otherwise, this will fail.',
+    ),
 };
-// Full schema for the mutation
+
 export const AddProductAssignmentZodSchema = z.object(AssignProductVariationSchema);
 
 export type AddProductAssignmentParams = z.infer<typeof AddProductAssignmentZodSchema>;
 
 export async function addProductAssignmentHandler(context: Context, params: AddProductAssignmentParams) {
   const { proxyId, productId, vectors } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler addProductAssignmentHandler', { userId, params });
     const proxyProduct = await modules.products.findProduct({
       productId: proxyId,
     });

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

@@ -0,0 +1,64 @@
+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';
+import { ProductTypes } from '@unchainedshop/core-products';
+
+const AddProductBundleItemInputSchema = z.object({
+  productId: z.string().min(1),
+  quantity: z.number().int().min(1),
+});
+
+export const AddProductBundleItemSchema = {
+  productId: z.string().min(1).describe('ID of the BUNDLE_PRODUCT to which the item will be added'),
+  item: AddProductBundleItemInputSchema,
+};
+
+export const AddProductBundleItemZodSchema = z.object(AddProductBundleItemSchema);
+
+export type AddProductBundleItemParams = z.infer<typeof AddProductBundleItemZodSchema>;
+export const addProductBundleItemHandler = async (
+  context: Context,
+  params: AddProductBundleItemParams,
+) => {
+  const { modules, userId } = context;
+  const { productId, item } = params;
+
+  log('handler addProductBundleItemHandler', { userId, params });
+
+  try {
+    const product = await modules.products.findProduct({ productId });
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    if (product.type !== ProductTypes.BundleProduct)
+      throw new ProductWrongTypeError({
+        productId,
+        received: product.type,
+        required: ProductTypes.BundleProduct,
+      });
+
+    if (!(await modules.products.productExists({ productId: item.productId })))
+      throw new ProductNotFoundError({ productId: item.productId });
+
+    await modules.products.bundleItems.addBundleItem(productId, item as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ product: await getNormalizedProductDetails(productId, context) }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error adding bundle item: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+};

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

@@ -2,14 +2,15 @@ import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 import { FileNotFoundError, FileUploadExpiredError } from '../../../errors.js';
+import normalizeMediaUrl from '../../utils/normalizeMediaUrl.js';
 
 export const AddProductMediaUploadSchema = {
   mediaName: z
     .string()
     .min(1)
-    .describe('Name of the media file (e.g. "image.png") use random name if not provided'),
+    .describe('Name of the media file (e.g. "image.png"); use random name if not provided'),
   productId: z.string().min(1).describe('ID of the product to link media to'),
-  url: z.string().describe('Anonymously fetchable URL of the source media, can be a data URL too'),
+  url: z.string().describe('Anonymously fetchable URL of the source media'),
 };
 
 export const AddProductMediaUploadZodSchema = z.object(AddProductMediaUploadSchema);
@@ -24,7 +25,7 @@ export async function addProductMediaUploadHandler(
   const { modules, services, userId } = context;
 
   try {
-    log('addProductMediaUploadHandler', { mediaName, productId, userId, url });
+    log('handler addProductMediaUploadHandler', { userId, params });
     const {
       _id: fileId,
       putURL,
@@ -61,7 +62,7 @@ export async function addProductMediaUploadHandler(
         {
           type: 'text' as const,
           text: JSON.stringify({
-            file: linked,
+            file: await normalizeMediaUrl([{ ...linked, mediaId: linked._id }], context),
           }),
         },
       ],

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

@@ -0,0 +1,61 @@
+import { Context } from '../../../context.js';
+import { ProductNotFoundError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
+import { z } from 'zod';
+
+export const CatalogPriceSchema = {
+  productId: z.string().min(1).describe('ID of the product to retrieve catalog price for'),
+  quantity: z
+    .number()
+    .int()
+    .positive()
+    .default(1)
+    .describe('Quantity to calculate catalog price for (default is 1)'),
+  currencyCode: z
+    .string()
+    .optional()
+    .describe('Optional currency code (e.g., "USD") for price calculation'),
+};
+
+export const CatalogPriceZodSchema = z.object(CatalogPriceSchema);
+export type CatalogPriceParams = z.infer<typeof CatalogPriceZodSchema>;
+
+export async function catalogPriceHandler(context: Context, params: CatalogPriceParams) {
+  const { productId, quantity, currencyCode: forcedCurrencyCode } = params;
+  const { modules, countryCode, currencyCode: defaultCurrencyCode, userId } = context;
+
+  try {
+    log('handler catalogPriceHandler', { userId, params });
+    const product = await getNormalizedProductDetails(productId, context);
+    if (!product) throw new ProductNotFoundError({ productId });
+    const currencyCode = forcedCurrencyCode || defaultCurrencyCode;
+    const catalogPrice = await modules.products.prices.price(product, {
+      countryCode,
+      currencyCode,
+      quantity,
+    });
+    const leveledCatalogPrice = await modules.products.prices.catalogPricesLeveled(product, {
+      currencyCode,
+      countryCode,
+    });
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ product, price: catalogPrice, leveledCatalogPrice }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+
+          text: `Error retrieving catalog price: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { Product, ProductText, ProductTypes } from '@unchainedshop/core-products';
+import { log } from '@unchainedshop/logger';
 const productTypeKeys = Object.keys(ProductTypes) as [
   keyof typeof ProductTypes,
   ...(keyof typeof ProductTypes)[],
@@ -39,11 +40,14 @@ export type CreateProductParams = z.infer<typeof CreateProductZodSchema>;
 
 export async function createProductHandler(context: Context, params: CreateProductParams) {
   const { product, texts } = params;
+  const { modules, userId } = context;
+
   try {
-    const newProduct = await context.modules.products.create(product as Product);
+    log('handler createProductHandler', { userId, params });
+    const newProduct = await modules.products.create(product as Product);
     let productTexts: any[] = texts;
     if (texts) {
-      productTexts = await context.modules.products.texts.updateTexts(
+      productTexts = await modules.products.texts.updateTexts(
         newProduct._id,
         texts as unknown as ProductText[],
       );

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

@@ -3,6 +3,7 @@ import { Context } from '../../../context.js';
 import { ProductTypes, ProductVariationType } from '@unchainedshop/core-products';
 import { ProductNotFoundError, ProductWrongTypeError } from '../../../errors.js';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 const productVariationTypeKeys = Object.keys(ProductVariationType) as [
   keyof typeof ProductVariationType,
@@ -47,9 +48,10 @@ export async function createProductVariationHandler(
   params: CreateProductVariationParams,
 ) {
   const { productId, variation, texts } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler createProductVariationHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (!product) throw new ProductNotFoundError({ productId });
 

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
 import { ProductVariationNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 const ProductVariationTextInputSchema = z.object({
   locale: z
@@ -30,8 +31,10 @@ export async function createProductVariationOptionHandler(
   params: CreateProductVariationOptionParams,
 ) {
   const { productVariationId, option, texts } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
+
   try {
+    log('handler createProductVariationOptionHandler', { userId, params });
     const variation = await modules.products.variations.findProductVariation({
       productVariationId,
     });

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

@@ -1,19 +1,14 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
-/**
- * Zod schema for the get_product tool (as raw object for MCP)
- */
 export const GetProductSchema = {
   productId: z.string().optional().describe('Product ID for lookup'),
   slug: z.string().optional().describe('Product slug for lookup'),
   sku: z.string().optional().describe('Product SKU for lookup'),
 };
 
-/**
- * Zod object schema for type inference and validation
- */
 export const GetProductZodSchema = z
   .object(GetProductSchema)
   .refine(
@@ -21,20 +16,15 @@ export const GetProductZodSchema = z
     'At least one of productId, slug, or sku must be provided',
   );
 
-/**
- * Interface for the get_product tool parameters
- */
 export type GetProductParams = z.infer<typeof GetProductZodSchema>;
 
-/**
- * Implementation of the get_product tool
- */
 export async function getProductHandler(context: Context, params: GetProductParams) {
   const { productId, slug, sku } = params;
+  const { modules, userId } = context;
 
   try {
-    // Find the product
-    const product = await context.modules.products.findProduct({
+    log('handler getProductHandler', { userId, params });
+    const product = await modules.products.findProduct({
       productId,
       slug,
       sku,