@unchainedshop/api 4.0.0-rc.11 → 4.0.0-rc.13

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

@@ -0,0 +1,231 @@
+import { z } from 'zod';
+import {
+  PaginationSchema,
+  SortingSchema,
+  SearchSchema,
+  DateRangeSchema,
+  OrderFilterSchema,
+} from '../../utils/sharedSchemas.js';
+
+export const OrderStatusEnum = z.enum(['PENDING', 'CONFIRMED', 'SHIPPED', 'DELIVERED', 'CANCELLED']);
+export const PaymentProviderTypeEnum = z.enum(['CARD', 'INVOICE', 'GENERIC']);
+export const DeliveryProviderTypeEnum = z.enum(['PICKUP', 'SHIPPING', 'LOCAL']);
+export const SortDirectionEnum = z.enum(['ASC', 'DESC']);
+
+export const SortOptionInput = z
+  .object({
+    key: z.string().min(1).describe('Field to sort by'),
+    value: SortDirectionEnum.describe('Sort direction'),
+  })
+  .strict();
+
+export const DateFilterInput = z.object(DateRangeSchema);
+
+export const actionValidators = {
+  LIST: z.object({
+    ...PaginationSchema,
+    ...SortingSchema,
+    ...SearchSchema,
+    ...OrderFilterSchema,
+    includeCarts: z.boolean().optional().describe('Include cart orders in results'),
+    paymentProviderTypes: z
+      .array(PaymentProviderTypeEnum)
+      .optional()
+      .describe('Filter by payment provider types'),
+    deliveryProviderTypes: z
+      .array(DeliveryProviderTypeEnum)
+      .optional()
+      .describe('Filter by delivery provider types'),
+    dateRange: DateFilterInput.optional().describe('Date range filter'),
+  }),
+
+  SALES_SUMMARY: z.object({
+    ...DateRangeSchema,
+    ...OrderFilterSchema,
+    days: z
+      .number()
+      .int()
+      .min(1)
+      .max(365)
+      .optional()
+      .describe('Number of days for daily breakdown (default: 30)'),
+  }),
+
+  MONTHLY_BREAKDOWN: z.object({
+    ...DateRangeSchema,
+    ...OrderFilterSchema,
+  }),
+
+  TOP_CUSTOMERS: z.object({
+    ...PaginationSchema,
+    ...DateRangeSchema,
+    customerStatus: z.string().optional().describe('Order status for customer analysis'),
+  }),
+
+  TOP_PRODUCTS: z.object({
+    ...PaginationSchema,
+    ...DateRangeSchema,
+  }),
+  GET_CART: z.object({
+    userId: z.string().describe('User ID to get cart for'),
+    orderNumber: z.string().optional().describe('Optional orderNumber if known to get user cart'),
+  }),
+  GET: z
+    .object({
+      orderId: z.string().optional().describe('Order ID of the order'),
+      orderNumber: z.string().optional().describe('Optional orderNumber if known to get user cart'),
+    })
+    .superRefine((data, ctx) => {
+      if (!data?.orderId && !data?.orderNumber) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: 'Either orderId or orderNumber is required',
+          path: ['GET'],
+        });
+      }
+    }),
+  PAY_ORDER: z
+    .object({
+      orderId: z
+        .string({
+          required_error: 'orderId is required to pay an order',
+          invalid_type_error: 'orderId must be a string',
+        })
+        .min(1, 'orderId cannot be empty')
+        .describe('The unique identifier of the order to mark as PAID'),
+    })
+    .describe(
+      "This operation is used for manually marking an order's payment as PAID. " +
+        'The following conditions must be met:\n' +
+        '- The order must already exist and must not be in OPEN (cart) status.\n' +
+        '- The order must have a valid payment record.\n' +
+        '- The payment status of the order must currently be OPEN.\n' +
+        'If these conditions are not met, an appropriate error will be thrown.',
+    ),
+  DELIVER_ORDER: z
+    .object({
+      orderId: z
+        .string({
+          required_error: 'orderId is required to mark an order as delivered',
+          invalid_type_error: 'orderId must be a string',
+        })
+        .min(1, 'orderId cannot be empty')
+        .describe('The unique identifier of the order to mark as DELIVERED'),
+    })
+    .describe(
+      "This operation is used for manually marking an order's delivery as DELIVERED. " +
+        'The following conditions must be met:\n' +
+        '- The order must exist and must not be in OPEN (cart) status.\n' +
+        '- The order must have a valid delivery record.\n' +
+        '- The delivery status of the order must currently be OPEN, if the order is confirmed.\n' +
+        'If these conditions are not satisfied, an appropriate error will be thrown.',
+    ),
+  CONFIRM_ORDER: z
+    .object({
+      orderId: z.string({ required_error: 'orderId is required' }).min(1, 'orderId cannot be empty'),
+      paymentContext: z
+        .record(z.any())
+        .optional()
+        .describe('Optional JSON context related to payment (e.g., transaction details).'),
+      deliveryContext: z
+        .record(z.any())
+        .optional()
+        .describe('Optional JSON context related to delivery (e.g., shipping info).'),
+      comment: z
+        .string()
+        .optional()
+        .describe('Optional comment or note to attach to the order confirmation.'),
+    })
+    .describe(
+      'Confirms an order. Requirements:\n' +
+        '- The order must exist.\n' +
+        '- The order status must be PENDING.\n' +
+        '- paymentContext, deliveryContext, and comment are optional additional inputs.',
+    ),
+  REJECT_ORDER: z
+    .object({
+      orderId: z
+        .string({ required_error: 'orderId is required' })
+        .min(1, 'orderId cannot be empty')
+        .describe('The unique identifier of the order to reject.'),
+      paymentContext: z
+        .record(z.any())
+        .optional()
+        .describe('Optional JSON context related to payment, e.g., transaction adjustments.'),
+      deliveryContext: z
+        .record(z.any())
+        .optional()
+        .describe('Optional JSON context related to delivery, e.g., shipment adjustments.'),
+      comment: z
+        .string()
+        .optional()
+        .describe('Optional comment explaining the reason for rejecting the order.'),
+    })
+    .describe(
+      'Manually rejects an order which is currently PENDING. ' +
+        'All additional properties (paymentContext, deliveryContext, comment) are forwarded to services.orders.rejectOrder.',
+    ),
+} as const;
+
+export const OrderManagementSchema = {
+  action: z
+    .enum([
+      'LIST',
+      'SALES_SUMMARY',
+      'MONTHLY_BREAKDOWN',
+      'TOP_CUSTOMERS',
+      'TOP_PRODUCTS',
+      'GET_CART',
+      'GET',
+      'PAY_ORDER',
+      'DELIVER_ORDER',
+      'CONFIRM_ORDER',
+      'REJECT_ORDER',
+    ])
+    .describe(
+      'Order action: LIST (get orders with filters), SALES_SUMMARY (daily sales analytics), MONTHLY_BREAKDOWN (12-month sales analysis), TOP_CUSTOMERS (highest spending customers), TOP_PRODUCTS (best-selling products), GET_CART (user cart), GET (single order), PAY_ORDER (mark single order as PAID), DELIVER_ORDER (mark single order as DELIVERED), CONFIRM_ORDER (manually mark order as CONFIRMED), REJECT_ORDER (reject order that is in progress)',
+    ),
+
+  ...PaginationSchema,
+  ...SortingSchema,
+  ...SearchSchema,
+  ...DateRangeSchema,
+  ...OrderFilterSchema,
+  includeCarts: z.boolean().optional().describe('Include cart orders in results (LIST only)'),
+  paymentProviderTypes: z
+    .array(PaymentProviderTypeEnum)
+    .optional()
+    .describe('Filter by payment provider types'),
+  deliveryProviderTypes: z
+    .array(DeliveryProviderTypeEnum)
+    .optional()
+    .describe('Filter by delivery provider types'),
+  dateRange: DateFilterInput.optional().describe('Date range filter'),
+
+  days: z
+    .number()
+    .int()
+    .min(1)
+    .max(365)
+    .optional()
+    .describe('Number of days for daily breakdown (SALES_SUMMARY only, default: 30)'),
+  customerStatus: z
+    .string()
+    .optional()
+    .describe('Order status for customer analysis (TOP_CUSTOMERS only)'),
+  orderId: z
+    .string()
+    .optional()
+    .describe(
+      'Optional ID of order, to get user cart (GET, PAY_ORDER & DELIVERY_ORDER, CONFIRM_ORDER & REJECT_ORDER only)',
+    ),
+  orderNumber: z.string().optional().describe('Optional orderNumber oof a order (GET_CART & GET only)'),
+  userId: z.string().optional().describe('User ID to get cart for (GET_CART only)'),
+};
+
+export const OrderManagementZodSchema = z.object(OrderManagementSchema);
+export type OrderManagementParams = z.infer<typeof OrderManagementZodSchema>;
+
+export type ActionName = keyof typeof actionValidators;
+export type Params<T extends ActionName> = z.infer<(typeof actionValidators)[T]>;
+export type Handler<T extends ActionName> = (orderModule: any, params: Params<T>) => Promise<unknown>;

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

@@ -0,0 +1,38 @@
+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';
+
+export default async function addBundleItem(context: Context, params: Params<'ADD_BUNDLE_ITEM'>) {
+  const { modules } = context;
+  const { bundleId, bundleProductId, quantity } = params;
+
+  const bundle = await modules.products.findProduct({ productId: bundleId });
+  if (!bundle) throw new ProductNotFoundError({ productId: bundleId });
+
+  if (bundle.type !== ProductTypes.BundleProduct) {
+    throw new ProductWrongTypeError({
+      productId: bundleId,
+      received: bundle.type,
+      required: ProductTypes.BundleProduct,
+    });
+  }
+
+  const bundleProduct = await modules.products.findProduct({ productId: bundleProductId });
+  if (!bundleProduct) throw new ProductNotFoundError({ productId: bundleProductId });
+
+  await modules.products.update(bundleId, {
+    ...bundle,
+    bundleItems: [
+      ...(bundle.bundleItems || []),
+      {
+        productId: bundleProductId,
+        quantity: quantity || 1,
+      },
+    ],
+  });
+
+  const product = await getNormalizedProductDetails(bundleId, context);
+  return { product };
+}

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

@@ -0,0 +1,70 @@
+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';
+
+export default async function addProductAssignment(context: Context, params: Params<'ADD_ASSIGNMENT'>) {
+  const { modules } = context;
+  const { proxyId, assignProductId, vectors } = params;
+
+  const proxyProduct = await modules.products.findProduct({ productId: proxyId });
+  if (!proxyProduct) throw new ProductNotFoundError({ productId: proxyId });
+
+  if (proxyProduct.type !== ProductTypes.ConfigurableProduct) {
+    throw new ProductWrongTypeError({
+      productId: proxyId,
+      received: proxyProduct.type,
+      required: ProductTypes.ConfigurableProduct,
+    });
+  }
+
+  // Extract variation matrix and validate vectors
+  const variations = await modules.products.variations.findProductVariations({ productId: proxyId });
+  const extractVariationMatrix = (variations = []) => {
+    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 combinations = cartesianProduct(options);
+    return combinations.map((combination) =>
+      combination.reduce((acc, value, index) => {
+        acc[keys[index]] = value;
+        return acc;
+      }, {}),
+    );
+  };
+
+  const combinationExists = (matrix, combination) => {
+    return matrix.some((variation) => {
+      return (
+        Object.keys(variation).length === Object.keys(combination).length &&
+        Object.entries(combination).every(([key, value]) => variation[key] === value)
+      );
+    });
+  };
+
+  const variationMatrix = extractVariationMatrix(variations);
+  const normalizedVectors = vectors?.reduce((prev, { key, value }) => {
+    return { ...prev, [key]: value };
+  }, {});
+
+  if (!combinationExists(variationMatrix, normalizedVectors)) {
+    throw new Error('Invalid variation vector combination');
+  }
+
+  const added = await modules.products.assignments.addProxyAssignment({
+    productId: assignProductId,
+    proxyId,
+    vectors: vectors as any,
+  });
+
+  if (!added) throw new Error('Assignment already exists');
+  const product = await getNormalizedProductDetails(assignProductId, context);
+
+  return { product, vectors };
+}

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

@@ -0,0 +1,46 @@
+import { Context } from '../../../../context.js';
+import { ProductNotFoundError } from '../../../../errors.js';
+import normalizeMediaUrl from '../../../utils/normalizeMediaUrl.js';
+import { Params } from '../schemas.js';
+
+export default async function addProductMedia(context: Context, params: Params<'ADD_MEDIA'>) {
+  const { modules, services } = context;
+  const { productId, mediaName, url } = params;
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  const {
+    _id: fileId,
+    putURL,
+    type,
+    size,
+  } = await services.files.createSignedURL({
+    directoryName: 'product-media',
+    fileName: mediaName,
+    meta: { productId },
+  });
+
+  const sourceResponse = await fetch(url);
+  const uploadUrl = new URL(putURL, process.env.ROOT_URL || 'http://localhost:4010');
+  const uploadResponse = await fetch(uploadUrl, {
+    method: 'PUT',
+    body: sourceResponse.body,
+    duplex: 'half',
+  } as RequestInit);
+
+  if (!uploadResponse.ok) {
+    throw new Error(`Upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
+  }
+
+  const file = await modules.files.findFile({ fileId });
+  if (!file) throw new Error(`File not found: ${fileId}`);
+
+  if (file.expires && new Date(file.expires).getTime() < Date.now()) {
+    throw new Error(`File upload expired: ${fileId}`);
+  }
+
+  const linked = await services.files.linkFile({ fileId, size, type });
+  const media = await normalizeMediaUrl([{ ...linked, mediaId: linked._id }], context);
+  return { media };
+}

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

@@ -0,0 +1,28 @@
+import { Context } from '../../../../context.js';
+import { ProductVariationNotFoundError } from '../../../../errors.js';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function addProductVariationOption(
+  context: Context,
+  params: Params<'ADD_VARIATION_OPTION'>,
+) {
+  const { modules } = context;
+  const { productVariationId, option, variationTexts } = params;
+
+  const variation = await modules.products.variations.findProductVariation({ productVariationId });
+  if (!variation) throw new ProductVariationNotFoundError({ productVariationId });
+
+  const newOption = await modules.products.variations.addVariationOption(productVariationId, {
+    value: option,
+  });
+
+  if (variationTexts && variationTexts.length > 0) {
+    await modules.products.variations.texts.updateVariationTexts(
+      productVariationId,
+      variationTexts as any[],
+      option,
+    );
+  }
+  return { product: await getNormalizedProductDetails(newOption.productId, context) };
+}

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

@@ -0,0 +1,15 @@
+import { Context } from '../../../../context.js';
+import { Params } from '../schemas.js';
+
+export default async function countProducts(context: Context, params: Params<'COUNT'>) {
+  const { modules } = context;
+  const { tags, slugs, queryString, includeDrafts = false } = params;
+
+  const count = await modules.products.count({
+    tags,
+    slugs,
+    queryString,
+    includeDrafts,
+  });
+  return { count };
+}

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

@@ -0,0 +1,14 @@
+import { Context } from '../../../../context.js';
+import { ProductNotFoundError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+
+export default async function countReviews(context: Context, params: Params<'COUNT_REVIEWS'>) {
+  const { modules } = context;
+  const { productId, queryString } = params;
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  const count = await modules.products.reviews.count({ productId, queryString });
+  return { count };
+}

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

@@ -0,0 +1,17 @@
+import { Context } from '../../../../context.js';
+import { ProductText } from '@unchainedshop/core-products';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function createProduct(context: Context, params: Params<'CREATE'>) {
+  const { modules } = context;
+  const { product, texts } = params;
+
+  const newProduct = await modules.products.create(product as any);
+
+  if (texts && texts.length > 0) {
+    await modules.products.texts.updateTexts(newProduct._id, texts as unknown as ProductText[]);
+  }
+
+  return { product: await getNormalizedProductDetails(newProduct._id, context) };
+}

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

@@ -0,0 +1,37 @@
+import { Context } from '../../../../context.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { ProductNotFoundError, ProductWrongTypeError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
+
+export default async function createProductVariation(
+  context: Context,
+  params: Params<'CREATE_VARIATION'>,
+) {
+  const { modules } = context;
+  const { productId, variation, variationTexts } = params;
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (product.type !== ProductTypes.ConfigurableProduct)
+    throw new ProductWrongTypeError({
+      productId,
+      received: product.type,
+      required: ProductTypes.ConfigurableProduct,
+    });
+
+  const newVariation = await modules.products.variations.create({
+    options: [],
+    productId,
+    ...variation,
+  });
+
+  if (variationTexts) {
+    await modules.products.variations.texts.updateVariationTexts(
+      newVariation._id,
+      variationTexts as any,
+    );
+  }
+  return { product: await getNormalizedProductDetails(productId, context) };
+}

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

@@ -0,0 +1,22 @@
+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';
+
+export default async function getBundleItems(context: Context, params: Params<'GET_BUNDLE_ITEMS'>) {
+  const { modules } = context;
+  const { bundleId } = params;
+
+  const bundle = await modules.products.findProduct({ productId: bundleId });
+  if (!bundle) throw new ProductNotFoundError({ productId: bundleId });
+
+  if (bundle.type !== ProductTypes.BundleProduct) {
+    throw new ProductWrongTypeError({
+      productId: bundleId,
+      received: bundle.type,
+      required: ProductTypes.BundleProduct,
+    });
+  }
+  return { product: await getNormalizedProductDetails(bundleId, context) };
+}

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

@@ -0,0 +1,31 @@
+import { Context } from '../../../../context.js';
+import { ProductNotFoundError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+
+export default async function getCatalogPrice(context: Context, params: Params<'GET_CATALOG_PRICE'>) {
+  const { modules, services } = context;
+  const { productId, quantity = 1, currencyCode } = params;
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  const currency = currencyCode || context.currencyCode;
+
+  const pricingContext = {
+    product,
+    user: context.user,
+    countryCode: context.countryCode,
+    currencyCode: currency,
+    quantity,
+  };
+
+  const pricing = await services.products.simulateProductPricing(pricingContext as any);
+  const unitPrice = pricing?.unitPrice();
+
+  const price = {
+    ...unitPrice,
+    isTaxable: pricing?.taxSum() > 0,
+    currencyCode: pricing?.currencyCode,
+  };
+  return { price };
+}

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

@@ -0,0 +1,14 @@
+import { Context } from '../../../../context.js';
+import { ProductMediaNotFoundError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+
+export default async function getMediaTexts(context: Context, params: Params<'GET_MEDIA_TEXTS'>) {
+  const { modules } = context;
+  const { productMediaId } = params;
+
+  const media = await modules.products.media.findProductMedia({ productMediaId });
+  if (!media) throw new ProductMediaNotFoundError({ productMediaId });
+
+  const texts = await modules.products.media.texts.findMediaTexts({ productMediaId });
+  return { texts };
+}

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

@@ -0,0 +1,21 @@
+import { Context } from '../../../../context.js';
+import { ProductNotFoundError } from '../../../../errors.js';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function getProduct(context: Context, params: Params<'GET'>) {
+  const { modules } = context;
+  const { productId, slug, sku } = params;
+
+  let query: any = {};
+  if (productId) query = { productId };
+  else if (slug) query = { slug };
+  else if (sku) query = { sku };
+  else throw new Error('Either productId, slug, or sku must be provided');
+
+  const foundProduct = await modules.products.findProduct(query);
+  if (!foundProduct) throw new ProductNotFoundError(query);
+
+  const product = await getNormalizedProductDetails(foundProduct._id, context);
+  return { product };
+}

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

@@ -0,0 +1,27 @@
+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';
+
+export default async function getProductAssignments(
+  context: Context,
+  params: Params<'GET_ASSIGNMENTS'>,
+) {
+  const { modules } = context;
+  const { productId, includeInactive = false } = params;
+
+  const product = await getNormalizedProductDetails(productId, context);
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (product.type !== ProductTypes.ConfigurableProduct) {
+    throw new ProductWrongTypeError({
+      productId,
+      received: product.type,
+      required: ProductTypes.ConfigurableProduct,
+    });
+  }
+
+  const assignments = await modules.products.proxyAssignments(product, { includeInactive });
+  return { assignments };
+}

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

@@ -0,0 +1,19 @@
+import { Context } from '../../../../context.js';
+import { ProductNotFoundError } from '../../../../errors.js';
+import normalizeMediaUrl from '../../../utils/normalizeMediaUrl.js';
+import { Params } from '../schemas.js';
+
+export default async function getProductMedia(context: Context, params: Params<'GET_MEDIA'>) {
+  const { modules } = context;
+  const { productId, tags, limit = 50, offset = 0 } = params;
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  const media = await modules.products.media.findProductMedias({
+    productId,
+    tags,
+    limit,
+    offset,
+  });
+  return { media: await normalizeMediaUrl(media, context) };
+}

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

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