@unchainedshop/api 4.0.0-rc.9 → 4.0.0

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

@@ -1,48 +0,0 @@
-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 PublishProductSchema = {
-  productId: z.string().min(1).describe('ID of the product to publish'),
-};
-
-export const PublishProductZodSchema = z.object(PublishProductSchema);
-
-export type PublishProductParams = z.infer<typeof PublishProductZodSchema>;
-
-export async function publishProductHandler(context: Context, params: PublishProductParams) {
-  const { productId } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler publishProductHandler', { userId, params });
-    const product = await modules.products.findProduct({ productId });
-    if (!product) throw new ProductNotFoundError({ productId });
-
-    if (!(await modules.products.publish(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 publishing product: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,63 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
-import { ProductWrongTypeError } from '../../../errors.js';
-import { ProductTypes } from '@unchainedshop/core-products';
-import { log } from '@unchainedshop/logger';
-
-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 RemoveProductAssignmentSchema = {
-  proxyId: z.string().min(1).describe('ID of the configurable_product'),
-  vectors: z
-    .array(ProductAssignmentVectorSchema)
-    .min(1)
-    .describe('Combination of attributes uniquely identifying the variant'),
-};
-export const RemoveProductAssignmentZodSchema = z.object(RemoveProductAssignmentSchema);
-export type RemoveProductAssignmentParams = z.infer<typeof RemoveProductAssignmentZodSchema>;
-
-export async function removeProductAssignmentHandler(
-  context: Context,
-  params: RemoveProductAssignmentParams,
-) {
-  const { proxyId, vectors } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler removeProductAssignmentHandler', { userId, params });
-    const product = await modules.products.findProduct({ productId: proxyId });
-
-    if (product.type !== ProductTypes.ConfigurableProduct)
-      throw new ProductWrongTypeError({
-        productId: proxyId,
-        received: product.type,
-        required: ProductTypes.ConfigurableProduct,
-      });
-
-    await modules.products.assignments.removeAssignment(proxyId, { vectors: vectors as any });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({
-            product: await getNormalizedProductDetails(proxyId, context),
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error removing product assignment: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,55 +0,0 @@
-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';
-
-export const RemoveProductBundleItemSchema = {
-  productId: z.string().min(1).describe('ID of the BUNDLE_PRODUCT from which the item will be removed'),
-  index: z.number().int().min(0).describe('0-based index of the bundle item to remove'),
-};
-
-export const RemoveProductBundleItemZodSchema = z.object(RemoveProductBundleItemSchema);
-
-export type RemoveProductBundleItemParams = z.infer<typeof RemoveProductBundleItemZodSchema>;
-
-export const removeProductBundleItemHandler = async (
-  context: Context,
-  params: RemoveProductBundleItemParams,
-) => {
-  const { modules, userId } = context;
-  const { productId, index } = params;
-
-  log('handler removeProductBundleItemHandler', { 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,
-      });
-
-    await modules.products.bundleItems.removeBundleItem(productId, index);
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ product: await getNormalizedProductDetails(productId, context) }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error removing bundle item: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-};

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

@@ -1,42 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
-import { log } from '@unchainedshop/logger';
-
-export const RemoveProductSchema = {
-  productId: z.string().min(1).describe('ID of the product to remove'),
-};
-
-export const RemoveProductZodSchema = z.object(RemoveProductSchema);
-
-export type RemoveProductParams = z.infer<typeof RemoveProductZodSchema>;
-
-export async function removeProductHandler(context: Context, params: RemoveProductParams) {
-  const { productId } = params;
-  const { services, userId } = context;
-
-  try {
-    log('handler removeProductHandler', { userId, params });
-    await services.products.removeProduct({ productId });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({
-            product: await getNormalizedProductDetails(productId, context),
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error removing product: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,49 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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}`,
-        },
-      ],
-    };
-  }
-}