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

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

@@ -1,6 +1,7 @@
 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'),
@@ -18,15 +19,18 @@ export async function translatedProductMediaTextsHandler(
   const { modules, userId } = context;
 
   try {
-    log(`handler translatedProductMediaTexts: ${productMediaId}`, { userId });
-
+    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 }),
+          text: JSON.stringify({ texts, productId: productMedia.productId }),
         },
       ],
     };

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

@@ -18,7 +18,7 @@ export async function translatedProductTextsHandler(
   const { modules, userId } = context;
 
   try {
-    log(`handler translatedProductTexts: ${productId}`, { userId });
+    log(`handler translatedProductTexts`, { userId, params });
 
     const texts = await modules.products.texts.findTexts({ productId });
 

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

@@ -1,6 +1,7 @@
 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'),
@@ -24,12 +25,14 @@ export async function translatedProductVariationTextsHandler(
   const { modules, userId } = context;
 
   try {
-    log(
-      `handler translatedProductVariationTexts: ${productVariationId} ${productVariationOptionValue || ''}`,
-      {
-        userId,
-      },
-    );
+    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,
@@ -40,7 +43,7 @@ export async function translatedProductVariationTextsHandler(
       content: [
         {
           type: 'text' as const,
-          text: JSON.stringify({ texts }),
+          text: JSON.stringify({ texts, productId: productVariation.productId }),
         },
       ],
     };

package/src/mcp/tools/product/{unPublishProduct.ts → unpublishProductHandler.ts}

@@ -2,6 +2,7 @@ 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'),
@@ -13,8 +14,8 @@ export type UnpublishProductParams = z.infer<typeof UnpublishProductZodSchema>;
 
 export async function unpublishProductHandler(context: Context, params: UnpublishProductParams) {
   const { productId } = params;
-  const { modules } = context;
-
+  const { modules, userId } = context;
+  log('handler unpublishProductHandler', { userId, params });
   try {
     const product = await modules.products.findProduct({ productId });
     if (!product) throw new ProductNotFoundError({ productId });

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductCommerceSchema = {
   productId: z
@@ -51,9 +52,10 @@ export async function updateProductCommerceHandler(
   params: UpdateProductCommerceParams,
 ) {
   const { productId, commerce } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductCommerceHandler', { userId, params });
     await modules.products.update(productId, { commerce });
 
     return {

package/src/mcp/tools/product/{updateProduct.ts → updateProductHandler.ts}

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { ProductNotFoundError } from '../../../errors.js';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductSchema = {
   productId: z.string().min(1).describe('ID of the product to update'),
@@ -20,9 +21,10 @@ export type UpdateProductParams = z.infer<typeof UpdateProductZodSchema>;
 
 export async function updateProductHandler(context: Context, params: UpdateProductParams) {
   const { productId, product } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductHandler', { userId, params });
     if (!(await modules.products.productExists({ productId })))
       throw new ProductNotFoundError({ productId });
 

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { ProductMediaNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductMediaTextsSchema = {
   productMediaId: z.string().min(1).describe('ID of the media asset to update'),
@@ -30,9 +31,10 @@ export async function updateProductMediaTextsHandler(
   params: UpdateProductMediaTextsParams,
 ) {
   const { productMediaId, texts } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductMediaTextsHandler', { userId, params });
     const productMedia = await modules.products.media.findProductMedia({
       productMediaId,
     });
@@ -44,7 +46,7 @@ export async function updateProductMediaTextsHandler(
       content: [
         {
           type: 'text' as const,
-          text: JSON.stringify({ texts: updatedTexts }),
+          text: JSON.stringify({ texts: updatedTexts, productId: productMedia.productId }),
         },
       ],
     };

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

@@ -3,16 +3,47 @@ import { Context } from '../../../context.js';
 import { ProductNotFoundError, ProductWrongStatusError } from '../../../errors.js';
 import { ProductTypes } from '@unchainedshop/core-products';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
+
+export const ProductPlanUsageCalculationTypeEnum = z.enum(['LICENSED', 'METERED'], {
+  description:
+    'Determines how usage is calculated for the product plan. LICENSED means a fixed license count, METERED means usage is tracked dynamically.',
+});
+
+export const ProductPlanConfigurationIntervalEnum = z.enum(
+  ['HOURS', 'DAYS', 'WEEKS', 'MONTHS', 'YEARS'],
+  {
+    description:
+      'Defines the time unit for billing intervals and trial periods (e.g., MONTHS means billing every month).',
+  },
+);
+
+export const UpdateProductPlanInputSchema = z.object({
+  usageCalculationType: ProductPlanUsageCalculationTypeEnum.describe(
+    'The billing usage calculation method for the product plan.',
+  ),
+  billingInterval: ProductPlanConfigurationIntervalEnum.describe(
+    'The interval unit used for billing cycles.',
+  ),
+  billingIntervalCount: z
+    .number()
+    .int()
+    .positive()
+    .describe('The number of billing intervals per billing cycle (e.g., 3 for every 3 months).'),
+  trialInterval: ProductPlanConfigurationIntervalEnum.optional().describe(
+    'Optional trial period interval unit before billing starts.',
+  ),
+  trialIntervalCount: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe('Number of trial intervals before the billing cycle starts.'),
+});
 
 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(),
-  }),
+  plan: UpdateProductPlanInputSchema.describe('Configuration settings for the product plan.'),
 };
 
 export const UpdateProductPlanZodSchema = z.object(UpdateProductPlanSchema);
@@ -21,9 +52,10 @@ export type UpdateProductPlanParams = z.infer<typeof UpdateProductPlanZodSchema>
 
 export async function updateProductPlanHandler(context: Context, params: UpdateProductPlanParams) {
   const { productId, plan } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductPlanHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (!product) throw new ProductNotFoundError({ productId });
 

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

@@ -3,6 +3,7 @@ import { Context } from '../../../context.js';
 import { ProductWrongTypeError } from '../../../errors.js';
 import { ProductTypes } from '@unchainedshop/core-products';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductSupplySchema = {
   productId: z
@@ -11,10 +12,25 @@ export const UpdateProductSupplySchema = {
     .describe('Product ID of a SIMPLE_PRODUCT only to update supply details for'),
   supply: z
     .object({
-      weightInGram: z.number().int().positive().optional(),
-      heightInMillimeters: z.number().int().positive().optional(),
-      lengthInMillimeters: z.number().int().positive().optional(),
-      widthInMillimeters: z.number().int().positive().optional(),
+      weightInGram: z.number().int().positive().optional().describe('Weight of the product in grams'),
+      heightInMillimeters: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Height of the product in millimeters'),
+      lengthInMillimeters: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Length of the product in millimeters'),
+      widthInMillimeters: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Width of the product in millimeters'),
     })
     .describe('Supply (delivery) attributes of the product'),
 };
@@ -25,9 +41,10 @@ export type UpdateProductSupplyParams = z.infer<typeof UpdateProductSupplyZodSch
 
 export async function updateProductSupplyHandler(context: Context, params: UpdateProductSupplyParams) {
   const { productId, supply } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductSupplyHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (product?.type !== ProductTypes.SimpleProduct)
       throw new ProductWrongTypeError({

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductTextsSchema = {
   productId: z.string().min(1).describe('ID of the product to update texts for'),
@@ -32,9 +33,10 @@ export type UpdateProductTextsParams = z.infer<typeof UpdateProductTextsZodSchem
 
 export async function updateProductTextsHandler(context: Context, params: UpdateProductTextsParams) {
   const { productId, texts } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductTextsHandler', { userId, params });
     await modules.products.texts.updateTexts(productId, texts as any[]);
     return {
       content: [

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

@@ -3,16 +3,19 @@ import { Context } from '../../../context.js';
 import { ProductTypes } from '@unchainedshop/core-products';
 import { ProductNotFoundError, ProductWrongStatusError } from '../../../errors.js';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductTokenizationSchema = {
   productId: z.string().min(1).describe('ID of the product of type TOKENIZED_PRODUCT to tokenize only'),
-  tokenization: z.object({
-    contractAddress: z.string().min(1),
-    contractStandard: z.string(),
-    tokenId: z.string().min(1),
-    supply: z.number().int().positive(),
-    ercMetadataProperties: z.record(z.any()).optional(),
-  }),
+  tokenization: z
+    .object({
+      contractAddress: z.string().min(1).describe('Blockchain contract address'),
+      contractStandard: z.string().describe('Standard of the smart contract (e.g., ERC-721)'),
+      tokenId: z.string().min(1).describe('Unique token identifier'),
+      supply: z.number().int().positive().describe('Total supply of the token'),
+      ercMetadataProperties: z.record(z.any()).optional().describe('Optional ERC metadata properties'),
+    })
+    .describe('Tokenization details'),
 };
 
 export const UpdateProductTokenizationZodSchema = z.object(UpdateProductTokenizationSchema);
@@ -23,9 +26,10 @@ export async function updateProductTokenizationHandler(
   params: UpdateProductTokenizationParams,
 ) {
   const { productId, tokenization } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductTokenizationHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (!product) throw new ProductNotFoundError({ productId });
 

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { ProductVariationNotFoundError } from '../../../errors.js';
+
+export const ProductVariationTextInputSchema = z.object({
+  locale: z.string().min(1).describe('Locale code (e.g., "en", "de")'),
+  title: z.string().optional().describe('Title of the variation in the given locale'),
+  subtitle: z.string().optional().describe('Subtitle of the variation in the given locale'),
+});
+
+export const UpdateProductVariationTextsSchema = {
+  productVariationId: z.string().min(1).describe('ID of the product variation to update'),
+  productVariationOptionValue: z
+    .string()
+    .optional()
+    .describe('Optional production option value to filter variations'),
+  texts: z
+    .array(ProductVariationTextInputSchema)
+    .min(1)
+    .describe('Localized texts to apply to the variation'),
+};
+
+export const UpdateProductVariationTextsZodSchema = z.object(UpdateProductVariationTextsSchema);
+
+export type UpdateProductVariationTextsParams = z.infer<typeof UpdateProductVariationTextsZodSchema>;
+
+export async function updateProductVariationTextsHandler(
+  context: Context,
+  params: UpdateProductVariationTextsParams,
+) {
+  const { productVariationId, productVariationOptionValue, texts } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler updateProductVariationTextsHandler', { userId, params });
+    const productVariation = await modules.products.variations.findProductVariation({
+      productVariationId,
+    });
+    if (!productVariation) throw new ProductVariationNotFoundError({ productVariationId });
+
+    const updatedTexts = await modules.products.variations.texts.updateVariationTexts(
+      productVariationId,
+      texts as any,
+      productVariationOptionValue,
+    );
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts: updatedTexts, productId: productVariation.productId }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating product warehousing: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -3,13 +3,16 @@ import { Context } from '../../../context.js';
 import { ProductWrongTypeError } from '../../../errors.js';
 import { ProductTypes } from '@unchainedshop/core-products';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductWarehousingSchema = {
-  productId: z.string().min(1).describe('ID of the SIMPLE_PRODUCT product type to update to be updated'),
-  warehousing: z.object({
-    sku: z.string().min(1).optional().describe('Stock keeping unit'),
-    baseUnit: z.string().min(1).optional().describe('Base unit of the product (e.g., "piece", "kg")'),
-  }),
+  productId: z.string().min(1).describe('ID of the SIMPLE_PRODUCT product type to update'),
+  warehousing: z
+    .object({
+      sku: z.string().min(1).optional().describe('Stock keeping unit'),
+      baseUnit: z.string().min(1).optional().describe('Base unit of the product (e.g., "piece", "kg")'),
+    })
+    .describe('Warehousing details to update'),
 };
 
 export const UpdateProductWarehousingZodSchema = z.object(UpdateProductWarehousingSchema);
@@ -21,9 +24,10 @@ export async function updateProductWarehousingHandler(
   params: UpdateProductWarehousingParams,
 ) {
   const { productId, warehousing } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductWarehousingHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (product?.type !== ProductTypes.SimpleProduct)
       throw new ProductWrongTypeError({

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

@@ -0,0 +1,61 @@
+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';
+
+const VariationProductsVectorSchema = z.object({
+  key: z.string().min(1),
+  value: z.string().min(1),
+});
+
+export const VariationProductsSchema = {
+  productId: z.string().min(1),
+  vectors: z.array(VariationProductsVectorSchema).min(1),
+  includeInactive: z.boolean().optional().default(true).describe('Whether to include inactive products'),
+};
+export const VariationProductsZodSchema = z.object(VariationProductsSchema);
+export type VariationProductsParams = z.infer<typeof VariationProductsZodSchema>;
+
+export const variationProductsHandler = async (context: Context, params: VariationProductsParams) => {
+  const { modules, userId } = context;
+  const { productId, vectors, includeInactive } = params;
+
+  try {
+    log('handler variationProductsHandler', { userId, params });
+    const product = await modules.products.findProduct({ productId });
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    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 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 variation products: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+};

package/src/mcp/tools/shopInfoHandler.ts

@@ -5,12 +5,14 @@ export async function shopInfoHandler(context: Context) {
   const { version, userId, loaders, locale, countryCode } = context;
 
   try {
-    log('query shopInfo', { userId });
+    log('handler shopInfoHandler', { userId });
 
     const language = await loaders.languageLoader.load({ isoCode: locale.language });
 
     const country = await loaders.countryLoader.load({ isoCode: countryCode });
-    const defaultLanguageIsoCode = language.isoCode + '-' + country.isoCode;
+    const defaultLanguageIsoCode = language?.isoCode
+      ? `${language.isoCode}${country?.isoCode ? '-' + country.isoCode : ''}`
+      : null;
 
     return {
       content: [

package/src/mcp/utils/getNormalizedProductDetails.ts

@@ -13,11 +13,38 @@ export async function getNormalizedProductDetails(productId: string, context: Co
     locale,
   });
   let variations = [];
+  let bundleItems = [];
   if (product.type === ProductTypes.ConfigurableProduct)
     variations = await context.modules.products.variations.findProductVariations({
       productId: product._id,
     });
 
+  if (product.type === ProductTypes.BundleProduct) {
+    bundleItems = await Promise.all(
+      (product.bundleItems || []).map(async (item) => {
+        const bundleItemProduct = await loaders.productLoader.load({
+          productId: item.productId,
+        });
+        const productMedias = await modules.products.media.findProductMedias({
+          productId: item.productId,
+        });
+        const media = await normalizeMediaUrl(productMedias, context);
+        const texts = await loaders.productTextLoader.load({
+          productId: item.productId,
+          locale,
+        });
+        return {
+          product: {
+            ...bundleItemProduct,
+            media,
+            texts,
+          },
+          ...item,
+        };
+      }),
+    );
+  }
+
   // Get pricing information
   let pricing = null;
   try {
@@ -37,6 +64,7 @@ export async function getNormalizedProductDetails(productId: string, context: Co
     texts,
     media,
     variations,
+    bundleItems,
     pricing,
   };
 }

package/src/resolvers/mutations/filters/createFilter.ts

@@ -2,6 +2,7 @@ import { log } from '@unchainedshop/logger';
 import { Filter } from '@unchainedshop/core-filters';
 import { Context } from '../../../context.js';
 import { FilterDirector, FilterInputText } from '@unchainedshop/core';
+import { DuplicateFilterKeyError } from '../../../errors.js';
 
 export default async function createFilter(
   root: never,
@@ -10,13 +11,17 @@ export default async function createFilter(
 ) {
   const { modules, userId } = context;
   log('mutation createFilter', { userId });
+  try {
+    const newFilter = await modules.filters.create(filter);
 
-  const newFilter = await modules.filters.create(filter);
+    await FilterDirector.invalidateProductIdCache(newFilter, context);
 
-  await FilterDirector.invalidateProductIdCache(newFilter, context);
-
-  if (texts) {
-    await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+    if (texts) {
+      await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+    }
+    return newFilter;
+  } catch (e) {
+    if (e?.message?.includes('duplicate')) throw new DuplicateFilterKeyError({ filter });
+    else throw e;
   }
-  return newFilter;
 }

package/src/schema/types/product/bundle-product.ts

@@ -1,7 +1,7 @@
 export default [
   /* GraphQL */ `
     """
-    A Bundle product consists of multiple configured products
+    A Bundle product consists of multiple products
     """
     type BundleProduct implements Product @cacheControl(maxAge: 180) {
       _id: ID!

package/lib/express/chatRouter.d.ts

@@ -1,3 +0,0 @@
-declare const chatRouter: import("express-serve-static-core").Router;
-export default chatRouter;
-//# sourceMappingURL=chatRouter.d.ts.map

package/lib/express/chatRouter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chatRouter.d.ts","sourceRoot":"","sources":["../../src/express/chatRouter.ts"],"names":[],"mappings":"AAwBA,QAAA,MAAM,UAAU,4CAAmB,CAAC;AAwEpC,eAAe,UAAU,CAAC"}