@unchainedshop/api 4.0.0-rc.16 → 4.0.0-rc.18

package/src/mcp/tools/order/handlers/payOrder.ts

@@ -2,6 +2,7 @@ import { OrderPaymentStatus } from '@unchainedshop/core-orders';
 import { Context } from '../../../../context.js';
 import {
   OrderNotFoundError,
+  OrderPaymentNotFoundError,
   OrderWrongPaymentStatusError,
   OrderWrongStatusError,
 } from '../../../../errors.js';
@@ -19,9 +20,13 @@ export default async function payOrder(context: Context, params: Params<'PAY_ORD
     throw new OrderWrongStatusError({ status: order.status });
   }
 
-  const payment = await modules.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId,
-  });
+  const payment =
+    order.paymentId &&
+    (await modules.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    }));
+
+  if (!payment) throw new OrderPaymentNotFoundError({ orderPaymentId: order.paymentId });
 
   if (modules.orders.payments.normalizedStatus(payment) !== OrderPaymentStatus.OPEN) {
     throw new OrderWrongPaymentStatusError({

package/src/mcp/tools/product/handlers/addBundleItem.ts

@@ -1,38 +1,39 @@
 import { Context } from '../../../../context.js';
 import { ProductTypes } from '@unchainedshop/core-products';
-import { ProductNotFoundError, ProductWrongTypeError } from '../../../../errors.js';
+import {
+  CyclicProductBundlingNotSupportedError,
+  ProductNotFoundError,
+  ProductWrongTypeError,
+} from '../../../../errors.js';
 import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
 import { Params } from '../schemas.js';
 
 export default async function addBundleItem(context: Context, params: Params<'ADD_BUNDLE_ITEM'>) {
   const { modules } = context;
   const { bundleId, bundleProductId, quantity } = params;
+  const product = await modules.products.findProduct({ productId: bundleId });
+  if (!product) throw new ProductNotFoundError({ productId: bundleId });
 
-  const bundle = await modules.products.findProduct({ productId: bundleId });
-  if (!bundle) throw new ProductNotFoundError({ productId: bundleId });
-
-  if (bundle.type !== ProductTypes.BundleProduct) {
+  if (product.type !== ProductTypes.BundleProduct)
     throw new ProductWrongTypeError({
       productId: bundleId,
-      received: bundle.type,
+      received: product.type,
       required: ProductTypes.BundleProduct,
     });
-  }
 
-  const bundleProduct = await modules.products.findProduct({ productId: bundleProductId });
-  if (!bundleProduct) throw new ProductNotFoundError({ productId: bundleProductId });
+  const itemProduct = await modules.products.findProduct({ productId: bundleProductId });
+  if (!itemProduct) throw new ProductNotFoundError({ productId: bundleProductId });
+
+  if (itemProduct._id === product._id)
+    throw new CyclicProductBundlingNotSupportedError({
+      productId: itemProduct._id,
+    });
 
-  await modules.products.update(bundleId, {
-    ...bundle,
-    bundleItems: [
-      ...(bundle.bundleItems || []),
-      {
-        productId: bundleProductId,
-        quantity: quantity || 1,
-      },
-    ],
+  await modules.products.bundleItems.addBundleItem(bundleId, {
+    productId: bundleProductId,
+    quantity,
+    configuration: [],
   });
 
-  const product = await getNormalizedProductDetails(bundleId, context);
-  return { product };
+  return { product: await getNormalizedProductDetails(bundleId, context) };
 }

package/src/mcp/tools/product/handlers/addProductAssignment.ts

@@ -1,5 +1,5 @@
 import { Context } from '../../../../context.js';
-import { ProductTypes } from '@unchainedshop/core-products';
+import { ProductTypes, ProductVariation } from '@unchainedshop/core-products';
 import { ProductNotFoundError, ProductWrongTypeError } from '../../../../errors.js';
 import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
 import { Params } from '../schemas.js';
@@ -21,15 +21,15 @@ export default async function addProductAssignment(context: Context, params: Par
 
   // Extract variation matrix and validate vectors
   const variations = await modules.products.variations.findProductVariations({ productId: proxyId });
-  const extractVariationMatrix = (variations = []) => {
+  const extractVariationMatrix = (variations: ProductVariation[] = []) => {
     const cartesianProduct = (arrays) => {
       return arrays.reduce(
         (acc, array) => acc.flatMap((item) => array.map((value) => [...item, value])),
         [[]],
       );
     };
-    const keys = variations.map((item) => item.key);
-    const options = variations.map((item) => item.options);
+    const keys = variations.map((item: any) => item.key);
+    const options = variations.map((item: any) => item.options);
     const combinations = cartesianProduct(options);
     return combinations.map((combination) =>
       combination.reduce((acc, value, index) => {

package/src/mcp/tools/product/handlers/addProductVariationOption.ts

@@ -1,3 +1,4 @@
+import { ProductVariation } from '@unchainedshop/core-products';
 import { Context } from '../../../../context.js';
 import { ProductVariationNotFoundError } from '../../../../errors.js';
 import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
@@ -13,9 +14,9 @@ export default async function addProductVariationOption(
   const variation = await modules.products.variations.findProductVariation({ productVariationId });
   if (!variation) throw new ProductVariationNotFoundError({ productVariationId });
 
-  const newOption = await modules.products.variations.addVariationOption(productVariationId, {
+  const newOption = (await modules.products.variations.addVariationOption(productVariationId, {
     value: option,
-  });
+  })) as ProductVariation;
 
   if (variationTexts && variationTexts.length > 0) {
     await modules.products.variations.texts.updateVariationTexts(

package/src/mcp/tools/product/handlers/createProductVariation.ts

@@ -23,6 +23,7 @@ export default async function createProductVariation(
 
   const newVariation = await modules.products.variations.create({
     options: [],
+    tags: [],
     productId,
     ...variation,
   });

package/src/mcp/tools/product/handlers/getCatalogPrice.ts

@@ -20,7 +20,9 @@ export default async function getCatalogPrice(context: Context, params: Params<'
   };
 
   const pricing = await services.products.simulateProductPricing(pricingContext as any);
-  const unitPrice = pricing?.unitPrice();
+  const unitPrice = pricing?.unitPrice({});
+
+  if (!pricing) return { price: null };
 
   const price = {
     ...unitPrice,

package/src/mcp/tools/product/handlers/getProductAssignments.ts

@@ -1,17 +1,17 @@
 import { Context } from '../../../../context.js';
 import { ProductTypes } from '@unchainedshop/core-products';
 import { ProductNotFoundError, ProductWrongTypeError } from '../../../../errors.js';
-import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
 import { Params } from '../schemas.js';
+import normalizeProxyAssignments from '../../../utils/normalizeProxyAssignments.js';
 
 export default async function getProductAssignments(
   context: Context,
   params: Params<'GET_ASSIGNMENTS'>,
 ) {
   const { modules } = context;
-  const { productId, includeInactive = false } = params;
+  const { productId } = params;
 
-  const product = await getNormalizedProductDetails(productId, context);
+  const product = await modules.products.findProduct({ productId });
   if (!product) throw new ProductNotFoundError({ productId });
 
   if (product.type !== ProductTypes.ConfigurableProduct) {
@@ -22,6 +22,10 @@ export default async function getProductAssignments(
     });
   }
 
-  const assignments = await modules.products.proxyAssignments(product, { includeInactive });
+  const assignments = await Promise.all(
+    (product?.proxy?.assignments || [])?.map(async (assignment) =>
+      normalizeProxyAssignments(assignment, context),
+    ),
+  );
   return { assignments };
 }

package/src/mcp/tools/product/handlers/index.ts

@@ -31,6 +31,7 @@ import getMediaTexts from './getMediaTexts.js';
 import getReviews from './getReviews.js';
 import countReviews from './countReviews.js';
 import getSiblings from './getSiblings.js';
+import updateProductTexts from './updateProductTexts.js';
 
 export const actionHandlers = {
   CREATE: createProduct,
@@ -66,4 +67,5 @@ export const actionHandlers = {
   GET_REVIEWS: getReviews,
   COUNT_REVIEWS: countReviews,
   GET_SIBLINGS: getSiblings,
+  UPDATE_PRODUCT_TEXTS: updateProductTexts,
 };

package/src/mcp/tools/product/handlers/removeProduct.ts

@@ -1,14 +1,34 @@
 import { Context } from '../../../../context.js';
-import { ProductNotFoundError } from '../../../../errors.js';
+import {
+  ProductLinkedToActiveBundleError,
+  ProductLinkedToActiveVariationError,
+  ProductLinkedToEnrollmentError,
+  ProductLinkedToQuotationError,
+  ProductNotFoundError,
+} from '../../../../errors.js';
 import { Params } from '../schemas.js';
 
 export default async function removeProduct(context: Context, params: Params<'REMOVE'>) {
-  const { modules } = context;
+  const { modules, services } = context;
   const { productId } = params;
 
   const product = await modules.products.findProduct({ productId });
   if (!product) throw new ProductNotFoundError({ productId });
+  const activeBundle = await modules.products.firstActiveProductBundle(productId);
+  if (activeBundle)
+    throw new ProductLinkedToActiveBundleError({ productId, bundleId: activeBundle._id });
+  const activeProxy = await modules.products.firstActiveProductProxy(productId);
+  if (activeProxy)
+    throw new ProductLinkedToActiveVariationError({ productId, proxyId: activeProxy._id });
+
+  const openQuotation = await modules.quotations.openQuotationWithProduct({ productId });
+  if (openQuotation)
+    throw new ProductLinkedToQuotationError({ productId, quotationId: openQuotation?._id });
+  const openEnrollment = await modules.enrollments.openEnrollmentWithProduct({ productId });
+  if (openEnrollment)
+    throw new ProductLinkedToEnrollmentError({ productId, enrollmentId: openEnrollment?._id });
+
+  await services.products.removeProduct({ productId });
 
-  await modules.products.delete(productId);
   return { success: true };
 }

package/src/mcp/tools/product/handlers/simulatePrice.ts

@@ -22,6 +22,8 @@ export default async function simulatePrice(context: Context, params: Params<'SI
   const pricing = await services.products.simulateProductPricing(pricingContext as any);
   const unitPrice = pricing?.unitPrice({ useNetPrice });
 
+  if (!pricing) return { price: null };
+
   const price = {
     ...unitPrice,
     isNetPrice: useNetPrice,

package/src/mcp/tools/product/handlers/simulatePriceRange.ts

@@ -31,6 +31,9 @@ export default async function simulatePriceRange(
   };
 
   const pricing = await services.products.simulateProductPricing(pricingContext as any);
+
+  if (!pricing) return { price: null };
+
   const minPrice = pricing?.unitPrice({ useNetPrice });
   const maxPrice = pricing?.unitPrice({ useNetPrice });
 

package/src/mcp/tools/product/handlers/updateProductMediaTexts.ts

@@ -1,3 +1,4 @@
+import { ProductMediaText } from '@unchainedshop/core-products';
 import { Context } from '../../../../context.js';
 import { ProductMediaNotFoundError } from '../../../../errors.js';
 import { Params } from '../schemas.js';
@@ -12,6 +13,9 @@ export default async function updateProductMediaTexts(
   const media = await modules.products.media.findProductMedia({ productMediaId });
   if (!media) throw new ProductMediaNotFoundError({ productMediaId });
 
-  const texts = await modules.products.media.texts.updateMediaTexts(productMediaId, mediaTexts);
+  const texts = await modules.products.media.texts.updateMediaTexts(
+    productMediaId,
+    mediaTexts as ProductMediaText[], // TODO: Fix with correct zod schema
+  );
   return { texts };
 }

package/src/mcp/tools/product/handlers/updateProductTexts.ts

@@ -0,0 +1,16 @@
+import { Context } from '../../../../context.js';
+import { ProductNotFoundError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+
+export default async function updateProductTexts(
+  context: Context,
+  params: Params<'UPDATE_PRODUCT_TEXTS'>,
+) {
+  const { modules } = context;
+  const { productId, texts } = params;
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  const productTexts = await modules.products.texts.updateTexts(productId, texts as any);
+  return { texts: productTexts };
+}

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

@@ -104,25 +104,25 @@ export const ProductSchema = z.object({
               .min(3)
               .max(3)
               .describe(
-                'ISO currency code (e.g., USD, EUR) make sure the currency code provided exists in the system currencies before using it. if it does not exists prompt the user to add the currency. NEVER add it automatically',
+                'ISO currency code (e.g., USD, EUR). Must match an available currency from the shop currencies resource. If it does not exist, prompt the user to add the currency. NEVER add it automatically unless explicitly specified by the user.',
               ),
             countryCode: z
               .string()
               .min(2)
               .max(2)
               .describe(
-                'ISO country code (e.g., US, DE) make sure the country/countryCode exists in the system before using it. if it does not exists prompt the user to add the country. NEVER add it automatically',
+                'ISO country code (e.g., US, DE). Must match an available country from the shop countries resource. If it does not exist, prompt the user to add the country. NEVER add it automatically unless explicitly specified by the user.',
               ),
           }),
         )
         .nonempty()
         .describe(
-          "List of price configurations always use countryCode and currencyCodes that are already registered in the system, don't use non existing iso codes.",
+          'List of price configurations. Use only countryCode and currencyCode values from the shop resources.',
         ),
     })
     .optional()
     .describe(
-      "Commerce info - Available for ALL except CONFIGURABLE_PRODUCT. always use countryCode and currencyCodes that are already registered in the system, don't use non existing iso codes.",
+      'Commerce info - Available for ALL except CONFIGURABLE_PRODUCT. Use only registered countries and currencies from shop resources.',
     ),
 });
 
@@ -144,7 +144,7 @@ export const actionValidators = {
       .string()
       .min(1)
       .describe(
-        'Product ID, (the product to remove must be inactive or in DRAFT state other wise it will throw error)',
+        'Product ID, (the product status to remove must be inactive or in DRAFT state other wise it will throw error) so if it is active please unpublish it first before removing the product',
       ),
   }),
 
@@ -269,7 +269,7 @@ export const actionValidators = {
   ADD_BUNDLE_ITEM: z.object({
     bundleId: z.string().min(1).describe('Bundle product ID'),
     bundleProductId: z.string().min(1).describe('Product to add to bundle'),
-    quantity: z.number().int().positive().optional().describe('Quantity'),
+    quantity: z.number().int().positive().default(1).describe('Quantity'),
   }),
 
   REMOVE_BUNDLE_ITEM: z.object({
@@ -333,6 +333,11 @@ export const actionValidators = {
     assortmentId: z.string().optional().describe('Assortment ID'),
     includeInactive: z.boolean().optional().describe('Include inactive products'),
   }),
+
+  UPDATE_PRODUCT_TEXTS: z.object({
+    productId: z.string().min(1).describe('Product ID'),
+    texts: z.array(ProductTextInputSchema).describe('Product texts to update'),
+  }),
 } as const;
 
 export const ProductManagementSchema = {
@@ -371,6 +376,7 @@ export const ProductManagementSchema = {
       'GET_REVIEWS',
       'COUNT_REVIEWS',
       'GET_SIBLINGS',
+      'UPDATE_PRODUCT_TEXTS',
     ])
     .describe('Product management action to perform'),
 
@@ -452,6 +458,9 @@ export const ProductManagementSchema = {
     .array(ProductAssignmentVectorSchema)
     .optional()
     .describe('Complete variation combination vectors'),
+
+  // eslint-disable-next-line
+  // @ts-expect-error
   includeInactive: z.boolean().optional().describe('Include inactive variants in results'),
 
   bundleId: z

package/src/mcp/tools/quotation/handlers/countQuotations.ts

@@ -0,0 +1,8 @@
+import { Context } from '../../../../context.js';
+import { Params } from '../schemas.js';
+
+export default async function countQuotations(context: Context, params: Params<'COUNT'>) {
+  const { modules } = context;
+
+  return modules.quotations.count(params);
+}

package/src/mcp/tools/quotation/handlers/getQuotation.ts

@@ -0,0 +1,8 @@
+import { Context } from '../../../../context.js';
+import { Params } from '../schemas.js';
+import { getNormalizedQuotationDetails } from '../../../utils/getNormalizedQuotationDetails.js';
+
+export default async function getQuotation(context: Context, params: Params<'GET'>) {
+  const { quotationId } = params;
+  return getNormalizedQuotationDetails(quotationId, context);
+}

package/src/mcp/tools/quotation/handlers/index.ts

@@ -0,0 +1,15 @@
+import listQuotations from './listQuotations.js';
+import getQuotation from './getQuotation.js';
+import countQuotations from './countQuotations.js';
+import verifyQuotation from './verifyQuotation.js';
+import makeQuotationProposal from './makeQuotationProposal.js';
+import rejectQuotation from './rejectQuotation.js';
+
+export default {
+  LIST: listQuotations,
+  GET: getQuotation,
+  COUNT: countQuotations,
+  VERIFY: verifyQuotation,
+  MAKE_PROPOSAL: makeQuotationProposal,
+  REJECT: rejectQuotation,
+};

package/src/mcp/tools/quotation/handlers/listQuotations.ts

@@ -0,0 +1,14 @@
+import { Context } from '../../../../context.js';
+import { Params } from '../schemas.js';
+import { getNormalizedQuotationDetails } from '../../../utils/getNormalizedQuotationDetails.js';
+
+export default async function listQuotations(context: Context, params: Params<'LIST'>) {
+  const { modules } = context;
+  const quotations = await modules.quotations.findQuotations(params as any);
+
+  return {
+    quotations: await Promise.all(
+      quotations.map((quotation) => getNormalizedQuotationDetails(quotation._id, context)),
+    ),
+  };
+}

package/src/mcp/tools/quotation/handlers/makeQuotationProposal.ts

@@ -0,0 +1,23 @@
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { Context } from '../../../../context.js';
+import { QuotationNotFoundError, QuotationWrongStatusError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+import { getNormalizedQuotationDetails } from '../../../utils/getNormalizedQuotationDetails.js';
+
+export default async function makeQuotationProposal(context: Context, params: Params<'MAKE_PROPOSAL'>) {
+  const { modules, services } = context;
+  const { quotationId, quotationContext } = params;
+  const quotation = await modules.quotations.findQuotation({ quotationId });
+  if (!quotation) throw new QuotationNotFoundError({ quotationId });
+
+  if (quotation.status !== QuotationStatus.PROCESSING) {
+    throw new QuotationWrongStatusError({ status: quotation.status });
+  }
+
+  const proposedQuotation = await services.quotations.proposeQuotation(
+    quotation,
+    quotationContext || {},
+  );
+
+  return getNormalizedQuotationDetails(proposedQuotation._id, context);
+}

package/src/mcp/tools/quotation/handlers/rejectQuotation.ts

@@ -0,0 +1,21 @@
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { Context } from '../../../../context.js';
+import { QuotationNotFoundError, QuotationWrongStatusError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+import { getNormalizedQuotationDetails } from '../../../utils/getNormalizedQuotationDetails.js';
+
+export default async function rejectQuotation(context: Context, params: Params<'REJECT'>) {
+  const { modules, services } = context;
+  const { quotationId, quotationContext } = params;
+
+  const quotation = await modules.quotations.findQuotation({ quotationId });
+  if (!quotation) throw new QuotationNotFoundError({ quotationId });
+
+  if (quotation.status === QuotationStatus.FULLFILLED) {
+    throw new QuotationWrongStatusError({ status: quotation.status });
+  }
+
+  const rejectedQuotation = await services.quotations.rejectQuotation(quotation, quotationContext || {});
+
+  return getNormalizedQuotationDetails(rejectedQuotation._id, context);
+}

package/src/mcp/tools/quotation/handlers/verifyQuotation.ts

@@ -0,0 +1,21 @@
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { Context } from '../../../../context.js';
+import { QuotationNotFoundError, QuotationWrongStatusError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+import { getNormalizedQuotationDetails } from '../../../utils/getNormalizedQuotationDetails.js';
+
+export default async function verifyQuotation(context: Context, params: Params<'VERIFY'>) {
+  const { modules, services } = context;
+  const { quotationId, quotationContext } = params;
+
+  const quotation = await modules.quotations.findQuotation({ quotationId });
+  if (!quotation) throw new QuotationNotFoundError({ quotationId });
+
+  if (quotation.status !== QuotationStatus.REQUESTED) {
+    throw new QuotationWrongStatusError({ status: quotation.status });
+  }
+
+  const verifiedQuotation = await services.quotations.verifyQuotation(quotation, quotationContext || {});
+
+  return getNormalizedQuotationDetails(verifiedQuotation._id, context);
+}

package/src/mcp/tools/quotation/index.ts

@@ -0,0 +1,12 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { quotationManagement, QuotationManagementSchema } from './quotationManagement.js';
+
+export const registerQuotationTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'quotation_management',
+    'Unified quotation management system. Supports: LIST (get quotations with filters and pagination), GET (single quotation by ID), COUNT (count quotations), REQUEST (create new quotation request for a product), VERIFY (verify a REQUESTED quotation), MAKE_PROPOSAL (create proposal for PROCESSING quotation), REJECT (reject any quotation except FULLFILLED). Quotations go through lifecycle: REQUESTED → PROCESSING → PROPOSED → FULLFILLED/REJECTED.',
+    QuotationManagementSchema,
+    async (params) => quotationManagement(context, params),
+  );
+};

package/src/mcp/tools/quotation/quotationManagement.ts

@@ -0,0 +1,34 @@
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import {
+  actionValidators,
+  QuotationManagementSchema,
+  QuotationManagementZodSchema,
+  QuotationManagementParams,
+  ActionName,
+} from './schemas.js';
+import actionHandlers from './handlers/index.js';
+import { createMcpResponse, createMcpErrorResponse } from '../../utils/sharedSchemas.js';
+
+export { QuotationManagementSchema, QuotationManagementZodSchema, QuotationManagementParams };
+
+export async function quotationManagement(context: Context, params: QuotationManagementParams) {
+  const { action, ...actionParams } = params;
+  log('MCP handler quotationManagement ', { userId: context.userId, params });
+
+  try {
+    if (!(action in actionHandlers)) {
+      throw new Error(`Unknown action: ${action}`);
+    }
+
+    const parsedParams = actionValidators[action as ActionName].parse(actionParams);
+    const data = await actionHandlers[action as ActionName](context, parsedParams as never);
+
+    return createMcpResponse({
+      action,
+      data,
+    });
+  } catch (error) {
+    return createMcpErrorResponse(action, error);
+  }
+}