@unchainedshop/api 4.0.0-rc.2 → 4.0.0-rc.3

package/src/mcp/tools/productReviewsCountHandler.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+
+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 } = context;
+
+  try {
+    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/productReviewsHandler.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { log } from '@unchainedshop/logger';
+
+const SortDirectionEnum = z.enum(['asc', 'desc']); // assuming these are your directions
+
+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,
+    });
+
+    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/productsCountHandler.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+
+export const ProductsCountSchema = {
+  tags: z.array(z.string().min(1)).optional(),
+  slugs: z.array(z.string().min(1)).optional(),
+  includeDrafts: z.boolean().default(false),
+  queryString: z.string().min(1).optional(),
+};
+
+export const ProductsCountZodSchema = z.object(ProductsCountSchema);
+export type ProductsCountParams = z.infer<typeof ProductsCountZodSchema>;
+
+export async function productsCountHandler(context: Context, params: ProductsCountParams) {
+  const { modules } = context;
+
+  try {
+    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}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/publishProduct.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../errors.js';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+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 } = context;
+  try {
+    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/removeLanguageHandler.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { LanguageNotFoundError } from '../../errors.js';
+
+export const RemoveLanguageSchema = {
+  languageId: z.string().min(1).describe('ID of the language to remove'),
+};
+
+export const RemoveLanguageZodSchema = z.object(RemoveLanguageSchema);
+export type RemoveLanguageParams = z.infer<typeof RemoveLanguageZodSchema>;
+
+export async function removeLanguageHandler(context: Context, params: RemoveLanguageParams) {
+  const { languageId } = params;
+  const { modules } = context;
+
+  try {
+    if (!(await modules.languages.languageExists({ languageId })))
+      throw new LanguageNotFoundError({ languageId });
+
+    await modules.languages.delete(languageId);
+
+    const removeLanguage = await modules.languages.findLanguage({ languageId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ language: removeLanguage }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing language: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/removeProductAssignmentHandler.ts

@@ -0,0 +1,61 @@
+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';
+
+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 } = context;
+
+  try {
+    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/removeProductHandler.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+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 } = context;
+
+  try {
+    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/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('removeProductMediaHandler', { userId, productMediaId });
+
+    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({
+            media: productMedia,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing product media: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/removeProductVariationHandler.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { ProductVariationNotFoundError } from '../../errors.js';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+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 } = context;
+
+  try {
+    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/removeProductVariationOptionHandler.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { ProductVariationNotFoundError } from '../../errors.js';
+
+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 } = context;
+
+  try {
+    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/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('mutation reorderProductMedia', { userId });
+
+    const reorderedMedia = await modules.products.media.updateManualOrder({ sortKeys: sortKeys as any });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ reorderedMedia }, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error reordering product media: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/unPublishProduct.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../errors.js';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+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 } = context;
+
+  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}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/updateLanguageHandler.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { LanguageNotFoundError } from '../../errors.js';
+
+const UpdateLanguageInputSchema = z.object({
+  isoCode: z.string().min(2).max(10).describe('Updated ISO code for the language'),
+  isActive: z.boolean().optional().describe('Whether the language is active'),
+});
+
+export const UpdateLanguageSchema = {
+  languageId: z.string().min(1).describe('ID of the language to update'),
+  language: UpdateLanguageInputSchema,
+};
+
+export const UpdateLanguageZodSchema = z.object(UpdateLanguageSchema);
+export type UpdateLanguageParams = z.infer<typeof UpdateLanguageZodSchema>;
+
+export async function updateLanguageHandler(context: Context, params: UpdateLanguageParams) {
+  const { languageId, language } = params;
+  const { modules } = context;
+
+  try {
+    if (!(await modules.languages.languageExists({ languageId })))
+      throw new LanguageNotFoundError({ languageId });
+
+    await modules.languages.update(languageId, language);
+
+    const updatedLanguage = await modules.languages.findLanguage({ languageId });
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ language: updatedLanguage }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating language: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/updateProduct.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { ProductNotFoundError } from '../../errors.js';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+export const UpdateProductSchema = {
+  productId: z.string().min(1).describe('ID of the product to update'),
+  product: z
+    .object({
+      tags: z.array(z.string().min(1).toLowerCase()).optional().describe('List of lowercase tags'),
+      sequence: z.number().int().optional().describe('Sorting sequence'),
+      meta: z.record(z.unknown()).optional().describe('Custom metadata as key-value pairs'),
+    })
+    .describe('Fields to update on the product'),
+};
+
+export const UpdateProductZodSchema = z.object(UpdateProductSchema);
+
+export type UpdateProductParams = z.infer<typeof UpdateProductZodSchema>;
+
+export async function updateProductHandler(context: Context, params: UpdateProductParams) {
+  const { productId, product } = params;
+  const { modules } = context;
+
+  try {
+    if (!(await modules.products.productExists({ productId })))
+      throw new ProductNotFoundError({ productId });
+
+    await modules.products.update(productId, product);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            product: await getNormalizedProductDetails(productId, context),
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating product: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}