@unchainedshop/api 3.1.13 → 4.0.0-rc.10

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { ProductMediaNotFoundError } from '../../../errors.js';
+
+export const RemoveProductMediaSchema = {
+  productMediaId: z.string().min(1).describe('ID of the product media to be removed'),
+};
+
+export const RemoveProductMediaZodSchema = z.object(RemoveProductMediaSchema);
+
+export type RemoveProductMediaParams = z.infer<typeof RemoveProductMediaZodSchema>;
+
+export async function removeProductMediaHandler(context: Context, params: RemoveProductMediaParams) {
+  const { productMediaId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler removeProductMediaHandler', { userId, params });
+
+    const productMedia = await modules.products.media.findProductMedia({
+      productMediaId,
+    });
+    if (!productMedia) throw new ProductMediaNotFoundError({ productMediaId });
+
+    await modules.files.delete(productMedia.mediaId);
+    await modules.products.media.delete(productMediaId);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            success: true,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing product media: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { ProductVariationNotFoundError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
+
+export const RemoveProductVariationSchema = {
+  productVariationId: z
+    .string()
+    .min(1)
+    .describe('ID of the product variation to remove. it should be a valid product variation ID'),
+};
+
+export const RemoveProductVariationZodSchema = z.object(RemoveProductVariationSchema);
+export type RemoveProductVariationParams = z.infer<typeof RemoveProductVariationZodSchema>;
+
+export async function removeProductVariationHandler(
+  context: Context,
+  params: RemoveProductVariationParams,
+) {
+  const { productVariationId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler removeProductVariationHandler', { userId, params });
+    const productVariation = await modules.products.variations.findProductVariation({
+      productVariationId,
+    });
+    if (!productVariation) throw new ProductVariationNotFoundError({ productVariationId });
+
+    await modules.products.variations.delete(productVariationId);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            product: await getNormalizedProductDetails(productVariationId, context),
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing product variation: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,60 @@
+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';
+
+export const RemoveProductVariationOptionSchema = {
+  productVariationId: z
+    .string()
+    .min(1)
+    .describe('ID of the product variation, it should be a CONFIGURABLE_PRODUCT type only'),
+  productVariationOptionValue: z
+    .string()
+    .min(1)
+    .describe('existing Option value in the product to remove (e.g., "Red")'),
+};
+
+export const RemoveProductVariationOptionZodSchema = z.object(RemoveProductVariationOptionSchema);
+export type RemoveProductVariationOptionParams = z.infer<typeof RemoveProductVariationOptionZodSchema>;
+
+export async function removeProductVariationOptionHandler(
+  context: Context,
+  params: RemoveProductVariationOptionParams,
+) {
+  const { productVariationId, productVariationOptionValue } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler removeProductVariationOptionHandler', { userId, params });
+    const productVariation = await modules.products.variations.findProductVariation({
+      productVariationId,
+    });
+    if (!productVariation) throw new ProductVariationNotFoundError({ productVariationId });
+
+    await modules.products.variations.removeVariationOption(
+      productVariationId,
+      productVariationOptionValue,
+    );
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            product: await getNormalizedProductDetails(productVariation.productId, context),
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing variation option: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,48 @@
+import { log } from '@unchainedshop/logger';
+import { Context } from '../../../context.js';
+import { z } from 'zod';
+
+export const ReorderProductMediaSchema = {
+  sortKeys: z
+    .array(
+      z.object({
+        productMediaId: z.string().min(1).describe('ID of the media asset'),
+        sortKey: z.number().int().describe('New sort key for ordering'),
+      }),
+    )
+    .min(1)
+    .describe('Array of product media IDs with their sort order'),
+};
+
+export const ReorderProductMediaZodSchema = z.object(ReorderProductMediaSchema);
+
+export type ReorderProductMediaParams = z.infer<typeof ReorderProductMediaZodSchema>;
+
+export async function reorderProductMediaHandler(context: Context, params: ReorderProductMediaParams) {
+  const { sortKeys } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler reorderProductMediaHandler', { userId, params });
+
+    const media = await modules.products.media.updateManualOrder({ sortKeys: sortKeys as any });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ media }, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error reordering product media: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,82 @@
+import { Context } from '../../../context.js';
+import { ProductNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
+import { z } from 'zod';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+
+export const ProductConfigurationParameterInputSchema = z.object({
+  key: z.string().min(1).describe('Configuration attribute key'),
+  value: z.string().min(1).describe('Configuration attribute value'),
+});
+
+export const SimulatedPriceSchema = {
+  productId: z.string().min(1).describe('ID of the product for which to simulate pricing'),
+  quantity: z
+    .number()
+    .int()
+    .positive()
+    .default(1)
+    .describe('Quantity to simulate price for (default is 1)'),
+  currencyCode: z.string().optional().describe('Currency code for price simulation (e.g., "USD")'),
+  useNetPrice: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('If true, returns net price; otherwise, returns gross price'),
+  configuration: z
+    .array(ProductConfigurationParameterInputSchema)
+    .optional()
+    .describe('Complete configuration vector (e.g., Color: Red, Size: M)'),
+};
+
+export const SimulatedPriceZodSchema = z.object(SimulatedPriceSchema);
+
+export type SimulatedPriceParams = z.infer<typeof SimulatedPriceZodSchema>;
+
+export async function simulatedPriceHandler(context: Context, params: SimulatedPriceParams) {
+  const { userId, countryCode, user, services } = context;
+  const { productId, quantity, configuration, currencyCode: forcedCurrencyCode, useNetPrice } = params;
+
+  try {
+    log('handler simulatedPriceHandler', { userId, params });
+
+    const product = await getNormalizedProductDetails(productId, context);
+    if (!product) throw new ProductNotFoundError({ productId });
+    const currencyCode = forcedCurrencyCode || context.currencyCode;
+    const pricingContext = {
+      product,
+      user,
+      countryCode,
+      currencyCode,
+      quantity,
+      configuration,
+    };
+    const pricing = await services.products.simulateProductPricing(pricingContext as any);
+    const unitPrice = pricing.unitPrice({ useNetPrice });
+
+    const price = {
+      ...unitPrice,
+      isNetPrice: useNetPrice,
+      isTaxable: pricing.taxSum() > 0,
+      currencyCode: pricing.currencyCode,
+    };
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ product, price }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error simulating price: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,126 @@
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { z } from 'zod';
+import { ProductWrongTypeError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+
+export const ProductAssignmentVectorInputSchema = z.object({
+  key: z.string().min(1).describe('Variation attribute key (e.g., "Color")'),
+  value: z.string().min(1).describe('Variation attribute value (e.g., "Red")'),
+});
+
+export const SimulatedPriceRangeSchema = {
+  productId: z.string().min(1).describe('ID of the CONFIGURABLE_PRODUCT to simulate price range for'),
+  quantity: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe('Desired quantity for price simulation (default is 1)'),
+  vectors: z
+    .array(ProductAssignmentVectorInputSchema)
+    .optional()
+    .describe('Optional variation key-value pairs (e.g., Color: Red) to simulate specific variant'),
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include inactive variants'),
+  currencyCode: z
+    .string()
+    .optional()
+    .describe('Currency code to simulate pricing with (e.g., "USD", "EUR")'),
+  useNetPrice: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Return net price if true, otherwise gross price'),
+};
+
+export const SimulatedPriceRangeZodSchema = z.object(SimulatedPriceRangeSchema);
+
+export type SimulatedPriceRangeParams = z.infer<typeof SimulatedPriceRangeZodSchema>;
+
+export async function simulatedPriceRangeHandler(context: Context, params: SimulatedPriceRangeParams) {
+  const {
+    productId,
+    quantity,
+    vectors,
+    includeInactive,
+    currencyCode: forcedCurrencyCode,
+    useNetPrice,
+  } = params;
+  const { modules, userId, countryCode, services } = context;
+
+  try {
+    log('handler simulatedPriceRangeHandler', { userId, params });
+
+    const currencyCode = forcedCurrencyCode || context.currencyCode;
+    const product = await getNormalizedProductDetails(productId, context);
+
+    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 filteredPrices = (
+      await Promise.all(
+        products.map(async (proxyProduct) => {
+          const pricingContext = {
+            product: proxyProduct,
+            user: context.user,
+            countryCode,
+            currencyCode,
+            quantity,
+          };
+
+          const pricing = await services.products.simulateProductPricing(pricingContext);
+          if (!pricing) return null;
+          const unitPrice = pricing.unitPrice({ useNetPrice });
+
+          return {
+            ...unitPrice,
+            isNetPrice: useNetPrice,
+            isTaxable: pricing.taxSum() > 0,
+            currencyCode: pricing.currencyCode,
+          };
+        }),
+      )
+    ).filter(Boolean);
+
+    if (!filteredPrices.length) return null;
+
+    const { minPrice, maxPrice } = modules.products.prices.priceRange({
+      productId: product._id as string,
+      prices: filteredPrices,
+    });
+
+    const priceRange = {
+      minPrice,
+      maxPrice,
+    };
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ product, priceRange }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error simulating price range: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { ProductMediaNotFoundError } from '../../../errors.js';
+
+export const TranslatedProductMediaTextsSchema = {
+  productMediaId: z.string().min(1).describe('ID of the product media to fetch translated texts for'),
+};
+
+export const TranslatedProductMediaTextsZodSchema = z.object(TranslatedProductMediaTextsSchema);
+
+export type TranslatedProductMediaTextsParams = z.infer<typeof TranslatedProductMediaTextsZodSchema>;
+
+export async function translatedProductMediaTextsHandler(
+  context: Context,
+  params: TranslatedProductMediaTextsParams,
+) {
+  const { productMediaId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler translatedProductMediaTexts`, { userId, params });
+    const productMedia = await modules.products.media.findProductMedia({
+      productMediaId,
+    });
+    if (!productMedia) throw new ProductMediaNotFoundError({ productMediaId });
+    const texts = await modules.products.media.texts.findMediaTexts({ productMediaId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts, productId: productMedia.productId }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting translated product media texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const TranslatedProductTextsSchema = {
+  productId: z.string().min(1).describe('ID of the product to fetch translated texts for'),
+};
+
+export const TranslatedProductTextsZodSchema = z.object(TranslatedProductTextsSchema);
+
+export type TranslatedProductTextsParams = z.infer<typeof TranslatedProductTextsZodSchema>;
+
+export async function translatedProductTextsHandler(
+  context: Context,
+  params: TranslatedProductTextsParams,
+) {
+  const { productId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler translatedProductTexts`, { userId, params });
+
+    const texts = await modules.products.texts.findTexts({ productId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting translated product texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { ProductVariationNotFoundError } from '../../../errors.js';
+
+export const TranslatedProductVariationTextsSchema = {
+  productVariationId: z.string().min(1).describe('ID of the product variation'),
+  productVariationOptionValue: z
+    .string()
+    .optional()
+    .describe('Optional specific variation option value'),
+};
+
+export const TranslatedProductVariationTextsZodSchema = z.object(TranslatedProductVariationTextsSchema);
+
+export type TranslatedProductVariationTextsParams = z.infer<
+  typeof TranslatedProductVariationTextsZodSchema
+>;
+
+export async function translatedProductVariationTextsHandler(
+  context: Context,
+  params: TranslatedProductVariationTextsParams,
+) {
+  const { productVariationId, productVariationOptionValue } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler translatedProductVariationTexts`, {
+      userId,
+      params,
+    });
+    const productVariation = await modules.products.variations.findProductVariation({
+      productVariationId,
+    });
+    if (!productVariation) throw new ProductVariationNotFoundError({ productVariationId });
+
+    const texts = await modules.products.variations.texts.findVariationTexts({
+      productVariationId,
+      productVariationOptionValue,
+    });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts, productId: productVariation.productId }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting translated product variation texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
+
+export const UnpublishProductSchema = {
+  productId: z.string().min(1).describe('ID of the product to unpublish'),
+};
+
+export const UnpublishProductZodSchema = z.object(UnpublishProductSchema);
+
+export type UnpublishProductParams = z.infer<typeof UnpublishProductZodSchema>;
+
+export async function unpublishProductHandler(context: Context, params: UnpublishProductParams) {
+  const { productId } = params;
+  const { modules, userId } = context;
+  log('handler unpublishProductHandler', { userId, params });
+  try {
+    const product = await modules.products.findProduct({ productId });
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    if (!(await modules.products.unpublish(product))) {
+      throw new ProductWrongStatusError({ status: product.status });
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            product: await getNormalizedProductDetails(productId, context),
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error unPublishing product: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}