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

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

@@ -1,76 +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';
-
-const ProductVariationTextInputSchema = z.object({
-  locale: z
-    .string()
-    .min(2)
-    .describe(
-      'locale iso code like "en-US", "de-CH" use default defaultLanguageIsoCode in shop info if not explicitly provided. if language is explicitly provided check if it exists',
-    ),
-  title: z.string().describe('variation option title in the specified locale'),
-  subtitle: z.string().optional().describe('variation option subtitle in the specified locale'),
-});
-
-export const CreateProductVariationOptionSchema = {
-  productVariationId: z
-    .string()
-    .min(1)
-    .describe('ID of the product variation, it should only be a CONFIGURABLE_PRODUCT type ID'),
-  option: z.string().min(1).describe('Name of the new option (e.g., "Red")'),
-  texts: z.array(ProductVariationTextInputSchema),
-};
-export const CreateProductVariationOptionZodSchema = z.object(CreateProductVariationOptionSchema);
-export type CreateProductVariationOptionParams = z.infer<typeof CreateProductVariationOptionZodSchema>;
-
-export async function createProductVariationOptionHandler(
-  context: Context,
-  params: CreateProductVariationOptionParams,
-) {
-  const { productVariationId, option, texts } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler createProductVariationOptionHandler', { userId, 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 (texts) {
-      await modules.products.variations.texts.updateVariationTexts(
-        productVariationId,
-        texts as any,
-        option,
-      );
-    }
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({
-            variation: newOption,
-            product: await getNormalizedProductDetails(newOption?.productId, context),
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error creating variation option: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,64 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
-import { log } from '@unchainedshop/logger';
-
-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'),
-};
-
-export const GetProductZodSchema = z
-  .object(GetProductSchema)
-  .refine(
-    (data) => data.productId || data.slug || data.sku,
-    'At least one of productId, slug, or sku must be provided',
-  );
-
-export type GetProductParams = z.infer<typeof GetProductZodSchema>;
-
-export async function getProductHandler(context: Context, params: GetProductParams) {
-  const { productId, slug, sku } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler getProductHandler', { userId, params });
-    const product = await modules.products.findProduct({
-      productId,
-      slug,
-      sku,
-    });
-
-    if (!product) {
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: `Product not found with ${productId ? `ID: ${productId}` : slug ? `slug: ${slug}` : `SKU: ${sku}`}`,
-          },
-        ],
-      };
-    }
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({
-            product: await getNormalizedProductDetails(productId, context),
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error getting product: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,56 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
-
-const SortOptionInputSchema = z.object({
-  key: z.string().min(1).describe('Field to sort by'),
-  value: z.enum(['ASC', 'DESC']).describe('Sort direction'),
-});
-
-export const ProductsListSchema = {
-  queryString: z.string().optional().describe('Free-text filter for products'),
-  tags: z.array(z.string().min(1).toLowerCase()).optional().describe('Filter by lowercase tags'),
-  slugs: z.array(z.string().min(1)).optional().describe('Filter by product slugs'),
-  limit: z.number().int().min(1).max(100).default(10).describe('Maximum number of products to return'),
-  offset: z.number().int().min(0).default(0).describe('Number of products to skip'),
-  includeDrafts: z.boolean().default(false).describe('Whether to include draft (unpublished) products'),
-  sort: z.array(SortOptionInputSchema).optional().describe('Sorting options'),
-};
-
-export const ProductsListZodSchema = z.object(ProductsListSchema);
-
-export type ProductsListParams = z.infer<typeof ProductsListZodSchema>;
-
-export async function productsListHandler(context: Context, params: ProductsListParams) {
-  const { modules, userId } = context;
-
-  try {
-    log('handler productsListHandler', { userId, params });
-
-    const products = await modules.products.findProducts(params as any);
-    const normalizedProducts = await Promise.all(
-      products.map(async ({ _id }) => getNormalizedProductDetails(_id, context)),
-    );
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({
-            products: normalizedProducts,
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error fetching products: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,86 +0,0 @@
-import { Context } from '../../../context.js';
-import { ProductNotFoundError, ProductWrongTypeError } from '../../../errors.js';
-import { ProductTypes } from '@unchainedshop/core-products';
-import { log } from '@unchainedshop/logger';
-import { z } from 'zod';
-import normalizeMediaUrl from '../../utils/normalizeMediaUrl.js';
-import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
-
-export const ProductAssignmentsSchema = {
-  productId: z
-    .string()
-    .min(1)
-    .describe('ID of the CONFIGURABLE_PRODUCT whose assignments should be fetched'),
-  includeInactive: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe('Whether to include inactive assigned products'),
-};
-
-export const ProductAssignmentsZodSchema = z.object(ProductAssignmentsSchema);
-export type ProductAssignmentsParams = z.infer<typeof ProductAssignmentsZodSchema>;
-
-export const productAssignmentsHandler = async (context: Context, params: ProductAssignmentsParams) => {
-  const { modules, userId, loaders, locale } = context;
-  const { productId, includeInactive } = params;
-
-  log('handler productAssignmentsHandler', { userId, params });
-  try {
-    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 });
-    const normalizedAssignments = await Promise.all(
-      assignments.map(async ({ assignment, ...rest }) => {
-        const product = await loaders.productLoader.load({
-          productId: assignment.productId,
-        });
-        const productMedias = await modules.products.media.findProductMedias({
-          productId: assignment.productId,
-        });
-        const media = await normalizeMediaUrl(productMedias, context);
-        const texts = await loaders.productTextLoader.load({
-          productId: assignment.productId,
-          locale,
-        });
-        return {
-          assignment: {
-            ...assignment,
-            product: {
-              ...product,
-              media,
-              texts,
-            },
-          },
-          ...rest,
-        };
-      }),
-    );
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ product, assignments: normalizedAssignments }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error fetching assignments: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-};

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

@@ -1,50 +0,0 @@
-import { Context } from '../../../context.js';
-import { ProductNotFoundError, ProductWrongTypeError } from '../../../errors.js';
-import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
-import { ProductTypes } from '@unchainedshop/core-products';
-import { log } from '@unchainedshop/logger';
-import { z } from 'zod';
-
-export const ProductBundleItemsSchema = {
-  productId: z.string().min(1).describe('ID of the product of type BUNDLE to retrieve its bundle items'),
-};
-
-export const ProductBundleItemsZodSchema = z.object(ProductBundleItemsSchema);
-export type ProductBundleItemsParams = z.infer<typeof ProductBundleItemsZodSchema>;
-
-export const productBundleItemsHandler = async (context: Context, params: ProductBundleItemsParams) => {
-  const { modules, userId } = context;
-  const { productId } = params;
-
-  log('handler productBundleItemsHandler', { 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,
-      });
-    }
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ product: await getNormalizedProductDetails(productId, context) }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error fetching bundle items: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-};

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

@@ -1,53 +0,0 @@
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-import { z } from 'zod';
-import normalizeMediaUrl from '../../utils/normalizeMediaUrl.js';
-
-export const ProductMediaSchema = {
-  productId: z.string().min(1).describe('ID of the product to retrieve media for'),
-  limit: z.number().int().min(1).max(100).default(10).describe('Number of media items to return'),
-  offset: z.number().int().min(0).default(0).describe('Pagination offset'),
-  tags: z.array(z.string().min(1)).optional().describe('Filter media by lowercase tags'),
-};
-
-export const ProductMediaZodSchema = z
-  .object(ProductMediaSchema)
-  .describe(
-    'Retrieve media assets associated with a product, optionally filtered by tags and paginated.',
-  );
-
-export type ProductMediaParams = z.infer<typeof ProductMediaZodSchema>;
-
-export async function productMediaHandler(context: Context, params: ProductMediaParams) {
-  const { productId, limit, offset, tags } = params;
-  const { modules, loaders, userId } = context;
-
-  try {
-    log('handler productMediaHandler', { userId, params });
-    let media = [];
-    if (offset || tags) {
-      media = await modules.products.media.findProductMedias({
-        productId,
-        ...params,
-      });
-    }
-    media = (await loaders.productMediasLoader.load({ productId })).slice(offset, offset + limit);
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ media: await normalizeMediaUrl(media, context) }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error retrieving product media: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,38 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const ProductReviewsCountSchema = {
-  queryString: z.string().optional().describe('Optional query string to filter reviews'),
-};
-
-export const ProductReviewsCountZodSchema = z.object(ProductReviewsCountSchema);
-
-export type ProductReviewsCountParams = z.infer<typeof ProductReviewsCountZodSchema>;
-
-export async function productReviewsCountHandler(context: Context, params: ProductReviewsCountParams) {
-  const { modules, userId } = context;
-
-  try {
-    log('handler productReviewsCountHandler', { userId, params });
-    const count = await modules.products.reviews.count(params);
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: count.toString(),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error fetching review count: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-const SortDirectionEnum = z.enum(['ASC', 'DESC']);
-
-export const ProductReviewsSchema = {
-  limit: z.number().int().min(1).max(100).default(10).describe('Number of reviews to return'),
-  offset: z.number().int().min(0).default(0).describe('Number of reviews to skip'),
-  sort: z
-    .array(
-      z.object({
-        key: z.string().min(1).describe('Field to sort by'),
-        value: SortDirectionEnum.describe('Sort direction: asc or desc'),
-      }),
-    )
-    .optional()
-    .describe('Sort options'),
-  queryString: z.string().optional().describe('Optional filter query'),
-};
-
-export const ProductReviewsZodSchema = z.object(ProductReviewsSchema);
-
-export type ProductReviewsParams = z.infer<typeof ProductReviewsZodSchema>;
-
-export async function productReviewsHandler(context: Context, params: ProductReviewsParams) {
-  const { limit, offset, queryString } = params;
-  const { modules, userId } = context;
-
-  try {
-    log(`query productReviews: ${limit} ${offset} ${queryString || ''}`, {
-      userId,
-      params,
-    });
-
-    const reviews = await modules.products.reviews.findProductReviews(params as any);
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ reviews }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error fetching product reviews: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,82 +0,0 @@
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-import { z } from 'zod';
-import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
-
-export const ProductSiblingsSchema = {
-  productId: z.string().describe('Product ID to get siblings of'),
-  assortmentId: z.string().optional().describe('Assortment ID to filter siblings (optional)'),
-  limit: z.number().int().min(1).max(100).default(10).describe('Number of siblings to return'),
-  offset: z.number().int().min(0).default(0).describe('Pagination offset'),
-  includeInactive: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe('Whether to include inactive sibling products'),
-};
-
-export const ProductSiblingsZodSchema = z
-  .object(ProductSiblingsSchema)
-  .describe(
-    'Retrieve sibling products of a given product, optionally filtered by assortment ID, with support for pagination and inclusion of inactive products.',
-  );
-
-export type ProductSiblingsParams = z.infer<typeof ProductSiblingsZodSchema>;
-
-export async function productSiblingsHandler(context: Context, params: ProductSiblingsParams) {
-  const { modules, userId } = context;
-  const { productId, assortmentId, limit, offset, includeInactive } = params;
-
-  try {
-    log('handler productSiblingsHandler', { userId, params });
-
-    const assortmentIds = assortmentId
-      ? [assortmentId]
-      : await modules.assortments.products.findAssortmentIds({ productId });
-
-    if (!assortmentIds.length)
-      return {
-        content: [
-          {
-            type: 'text' as const,
-            text: JSON.stringify({ products: [] }),
-          },
-        ],
-      };
-
-    const productIds = await modules.assortments.products.findSiblings({
-      productId,
-      assortmentIds,
-    });
-
-    const products = await modules.products.findProducts({
-      productIds,
-      includeDrafts: includeInactive,
-      limit,
-      offset,
-    });
-
-    const normalizedProducts = (
-      await Promise.allSettled(products.map(({ _id }) => getNormalizedProductDetails(_id, context)))
-    ).flatMap((r) => (r.status === 'fulfilled' ? [r.value] : []));
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ products: normalizedProducts }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error retrieving product siblings: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,53 +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';
-
-export const ProductVariationsSchema = {
-  productId: z.string().min(1).describe('ID of the CONFIGURABLE_PRODUCT to retrieve variations from'),
-};
-
-export const ProductVariationsZodSchema = z.object(ProductVariationsSchema);
-export type ProductVariationsParams = z.infer<typeof ProductVariationsZodSchema>;
-
-export const productVariationsHandler = async (context: Context, params: ProductVariationsParams) => {
-  const { productId } = params;
-  const { modules, userId } = context;
-
-  try {
-    log('handler productVariationsHandler', { userId, productId });
-
-    const product = await getNormalizedProductDetails(productId, context);
-    if (!product) throw new ProductNotFoundError({ productId });
-
-    if (product.type !== 'CONFIGURABLE_PRODUCT') {
-      throw new ProductWrongTypeError({
-        productId,
-        received: product.type,
-        required: 'CONFIGURABLE_PRODUCT',
-      });
-    }
-    const variations = await modules.products.variations.findProductVariations({
-      productId,
-    });
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ product, variations }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error fetching variations: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-};

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

@@ -1,40 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const ProductsCountSchema = {
-  tags: z.array(z.string().min(1)).optional().describe('Filter products by tags'),
-  slugs: z.array(z.string().min(1)).optional().describe('Filter products by slugs'),
-  includeDrafts: z.boolean().default(false).describe('Include draft (unpublished) products'),
-  queryString: z.string().min(1).optional().describe('Text query to filter products'),
-};
-
-export const ProductsCountZodSchema = z.object(ProductsCountSchema);
-export type ProductsCountParams = z.infer<typeof ProductsCountZodSchema>;
-
-export async function productsCountHandler(context: Context, params: ProductsCountParams) {
-  const { modules, userId } = context;
-
-  try {
-    log('handler productsCountHandler', { userId, params });
-    const count = await modules.products.count(params);
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: count.toString(),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error counting products: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}