@unchainedshop/api 3.1.13 → 4.0.0-rc.3

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}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/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/updateProductMediaTextsHandler.ts

@@ -0,0 +1,56 @@
+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 of the text, e.g. "en", "fr", etc.'),
+        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/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}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/updateProductSupplyHandler.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { ProductWrongTypeError } from '../../errors.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+export const UpdateProductSupplySchema = {
+  productId: z
+    .string()
+    .min(1)
+    .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(),
+    })
+    .describe('Supply (delivery) attributes of the product'),
+};
+
+export const UpdateProductSupplyZodSchema = z.object(UpdateProductSupplySchema);
+
+export type UpdateProductSupplyParams = z.infer<typeof UpdateProductSupplyZodSchema>;
+
+export async function updateProductSupplyHandler(context: Context, params: UpdateProductSupplyParams) {
+  const { productId, supply } = params;
+  const { modules } = context;
+
+  try {
+    const product = await modules.products.findProduct({ productId });
+    if (product?.type !== ProductTypes.SimpleProduct)
+      throw new ProductWrongTypeError({
+        productId,
+        received: product?.type,
+        required: ProductTypes.SimpleProduct,
+      });
+
+    await modules.products.update(productId, { supply });
+
+    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 supply: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/updateProductTextsHandler.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+export const UpdateProductTextsSchema = {
+  productId: z.string().min(1).describe('ID of the product to update texts for'),
+  texts: z
+    .array(
+      z.object({
+        locale: z
+          .string()
+          .min(2)
+          .describe(
+            'Locale code like "en", "de" always use locales registered in the system languages, if explicitly provided check if it exists',
+          ),
+        slug: z.string().optional().describe('URL slug'),
+        title: z.string().optional().describe('Product title'),
+        subtitle: z.string().optional().describe('Product subtitle'),
+        description: z.string().optional().describe('Markdown description'),
+        vendor: z.string().optional().describe('Vendor name'),
+        brand: z.string().optional().describe('Brand name'),
+        labels: z.array(z.string()).optional().describe('Labels or tags'),
+      }),
+    )
+    .nonempty()
+    .describe('Localized product text entries'),
+};
+
+export const UpdateProductTextsZodSchema = z.object(UpdateProductTextsSchema);
+
+export type UpdateProductTextsParams = z.infer<typeof UpdateProductTextsZodSchema>;
+
+export async function updateProductTextsHandler(context: Context, params: UpdateProductTextsParams) {
+  const { productId, texts } = params;
+  const { modules } = context;
+
+  try {
+    await modules.products.texts.updateTexts(productId, texts as any[]);
+    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 texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/updateProductTokenizationHandler.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../errors.js';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+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(),
+  }),
+};
+
+export const UpdateProductTokenizationZodSchema = z.object(UpdateProductTokenizationSchema);
+export type UpdateProductTokenizationParams = z.infer<typeof UpdateProductTokenizationZodSchema>;
+
+export async function updateProductTokenizationHandler(
+  context: Context,
+  params: UpdateProductTokenizationParams,
+) {
+  const { productId, tokenization } = params;
+  const { modules } = context;
+
+  try {
+    const product = await modules.products.findProduct({ productId });
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    if (product?.type !== ProductTypes.TokenizedProduct)
+      throw new ProductWrongStatusError({
+        received: product?.type,
+        required: ProductTypes.TokenizedProduct,
+      });
+
+    await modules.products.update(productId, { tokenization });
+
+    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 tokenization: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/updateProductWarehousingHandler.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { Context } from '../../context.js';
+import { ProductWrongTypeError } from '../../errors.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+
+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")'),
+  }),
+};
+
+export const UpdateProductWarehousingZodSchema = z.object(UpdateProductWarehousingSchema);
+
+export type UpdateProductWarehousingParams = z.infer<typeof UpdateProductWarehousingZodSchema>;
+
+export async function updateProductWarehousingHandler(
+  context: Context,
+  params: UpdateProductWarehousingParams,
+) {
+  const { productId, warehousing } = params;
+  const { modules } = context;
+
+  try {
+    const product = await modules.products.findProduct({ productId });
+    if (product?.type !== ProductTypes.SimpleProduct)
+      throw new ProductWrongTypeError({
+        productId,
+        received: product.type,
+        required: ProductTypes.SimpleProduct,
+      });
+
+    await modules.products.update(productId, { warehousing });
+    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 warehousing: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/utils/getNormalizedProductDetails.ts

@@ -0,0 +1,42 @@
+import { ProductTypes } from '@unchainedshop/core-products';
+import { Context } from '../../context.js';
+import normalizeMediaUrl from './normalizeMediaUrl.js';
+
+export async function getNormalizedProductDetails(productId: string, context: Context) {
+  const { modules, locale, loaders } = context;
+  const product = await modules.products.findProduct({ productId });
+
+  if (!product) return null;
+
+  const texts = await loaders.productTextLoader.load({
+    productId,
+    locale,
+  });
+  let variations = [];
+  if (product.type === ProductTypes.ConfigurableProduct)
+    variations = await context.modules.products.variations.findProductVariations({
+      productId: product._id,
+    });
+
+  // Get pricing information
+  let pricing = null;
+  try {
+    pricing = await context.modules.products.prices.price(product, {
+      countryCode: context.countryCode,
+    });
+  } catch {
+    // Pricing might not be available for all products
+    console.warn('Pricing not available for product:', product._id);
+  }
+
+  const productMedias = await modules.products.media.findProductMedias({ productId });
+  const media = await normalizeMediaUrl(productMedias, context);
+
+  return {
+    ...product,
+    texts,
+    media,
+    variations,
+    pricing,
+  };
+}

package/src/mcp/utils/normalizeMediaUrl.ts

@@ -0,0 +1,26 @@
+import { getFileAdapter } from '@unchainedshop/core-files';
+
+const normalizeMediaUrl = async (medias = [], context) => {
+  if (medias?.length) {
+    const normalizedMedias = await Promise.all(
+      medias.map(async (media) => {
+        const file = await context.loaders.fileLoader.load({
+          fileId: media.mediaId,
+        });
+        const fileUploadAdapter = getFileAdapter();
+        const url = await fileUploadAdapter.createDownloadURL(file);
+        file.url = context.modules.files.normalizeUrl(url, {});
+
+        return {
+          ...media,
+          file,
+        };
+      }),
+    );
+
+    return normalizedMedias.filter(Boolean);
+  }
+  return medias;
+};
+
+export default normalizeMediaUrl;

package/src/resolvers/mutations/accounts/createUser.ts

@@ -32,17 +32,15 @@ export default async function createUser(root: never, params: UserRegistrationDa
       {},
     );
 
-    let user = await modules.users.findUserById(newUserId);
-
-    user = await context.modules.users.updateHeartbeat(user._id, {
+    const user = await context.modules.users.updateHeartbeat(newUserId, {
       remoteAddress: context.remoteAddress,
       remotePort: context.remotePort,
       userAgent: context.getHeader('user-agent'),
-      locale: context.localeContext.baseName,
-      countryCode: context.countryContext,
+      locale: context.locale.baseName,
+      countryCode: context.countryCode,
     });
 
-    await context.services.orders.nextUserCart({ user, countryCode: context.countryContext });
+    await context.services.orders.nextUserCart({ user, countryCode: context.countryCode });
 
     return context.login(user);
   } catch (e) {

package/src/resolvers/mutations/accounts/impersonate.ts

@@ -17,7 +17,7 @@ const impersonate = async (root, { userId }, context: Context) => {
 
   await context.services.orders.nextUserCart({
     user: userToImpersonate,
-    countryCode: context.countryContext,
+    countryCode: context.countryCode,
   });
 
   return context.login(userToImpersonate, {