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

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('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/product/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/product/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/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 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/product/translatedProductMediaTextsHandler.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+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: ${productMediaId}`, { userId });
+
+    const texts = await modules.products.media.texts.findMediaTexts({ productMediaId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts }),
+        },
+      ],
+    };
+  } 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: ${productId}`, { userId });
+
+    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,57 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+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: ${productVariationId} ${productVariationOptionValue || ''}`,
+      {
+        userId,
+      },
+    );
+
+    const texts = await modules.products.variations.texts.findVariationTexts({
+      productVariationId,
+      productVariationOptionValue,
+    });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting translated product variation texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/product/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/product/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}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+
+export const UpdateProductCommerceSchema = {
+  productId: z
+    .string()
+    .min(1)
+    .describe('ID of the product of all type except for CONFIGURABLE_PRODUCT to update commerce info'),
+  commerce: z
+    .object({
+      pricing: z
+        .array(
+          z.object({
+            amount: z.number().int().describe('Price amount in smallest currency unit (e.g., cents)'),
+            maxQuantity: z
+              .number()
+              .int()
+              .optional()
+              .describe('Optional maximum quantity for this price tier'),
+            isTaxable: z.boolean().optional().describe('Whether tax applies to this price'),
+            isNetPrice: z.boolean().optional().describe('Whether this is a net price (without tax)'),
+            currencyCode: z
+              .string()
+              .min(3)
+              .max(3)
+              .describe(
+                'ISO currency code (e.g., USD, EUR) always use values registered in the system and if explicitly provided check if it exists',
+              ),
+            countryCode: z
+              .string()
+              .min(2)
+              .max(2)
+              .describe(
+                'ISO country code (e.g., US, DE) always use values registered in the system and if explicitly provided check if it exists',
+              ),
+          }),
+        )
+        .nonempty()
+        .describe('List of price configurations'),
+    })
+    .describe('Commerce info to update'),
+};
+
+export const UpdateProductCommerceZodSchema = z.object(UpdateProductCommerceSchema);
+
+export type UpdateProductCommerceParams = z.infer<typeof UpdateProductCommerceZodSchema>;
+
+export async function updateProductCommerceHandler(
+  context: Context,
+  params: UpdateProductCommerceParams,
+) {
+  const { productId, commerce } = params;
+  const { modules } = context;
+
+  try {
+    await modules.products.update(productId, { commerce });
+
+    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 commerce info: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { ProductMediaNotFoundError } from '../../../errors.js';
+
+export const UpdateProductMediaTextsSchema = {
+  productMediaId: z.string().min(1).describe('ID of the media asset to update'),
+  texts: z
+    .array(
+      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().optional().describe('Title in the given locale'),
+        subtitle: z.string().optional().describe('Subtitle in the given locale'),
+      }),
+    )
+    .min(1)
+    .describe('List of localized texts to update'),
+};
+
+export const UpdateProductMediaTextsZodSchema = z.object(UpdateProductMediaTextsSchema);
+
+export type UpdateProductMediaTextsParams = z.infer<typeof UpdateProductMediaTextsZodSchema>;
+
+export async function updateProductMediaTextsHandler(
+  context: Context,
+  params: UpdateProductMediaTextsParams,
+) {
+  const { productMediaId, texts } = params;
+  const { modules } = context;
+
+  try {
+    const productMedia = await modules.products.media.findProductMedia({
+      productMediaId,
+    });
+    if (!productMedia) throw new ProductMediaNotFoundError({ productMediaId });
+
+    const updatedTexts = await modules.products.media.texts.updateMediaTexts(productMediaId, texts);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts: updatedTexts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating product media texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../../errors.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+
+export const UpdateProductPlanSchema = {
+  productId: z.string().min(1).describe('ID of the product of type PLAN_PRODUCT to update only'),
+  plan: z.object({
+    usageCalculationType: z.string(),
+    billingInterval: z.string(),
+    billingIntervalCount: z.number().int().positive().optional(),
+    trialInterval: z.string().optional(),
+    trialIntervalCount: z.number().int().positive().optional(),
+  }),
+};
+
+export const UpdateProductPlanZodSchema = z.object(UpdateProductPlanSchema);
+
+export type UpdateProductPlanParams = z.infer<typeof UpdateProductPlanZodSchema>;
+
+export async function updateProductPlanHandler(context: Context, params: UpdateProductPlanParams) {
+  const { productId, plan } = params;
+  const { modules } = context;
+
+  try {
+    const product = await modules.products.findProduct({ productId });
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    if (product?.type !== ProductTypes.PlanProduct)
+      throw new ProductWrongStatusError({
+        received: product?.type,
+        required: ProductTypes.PlanProduct,
+      });
+
+    await modules.products.update(productId, { plan });
+
+    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 plan: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}