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

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/products/addProductAssignment.ts

@@ -9,6 +9,7 @@ import {
   ProductWrongTypeError,
   ProductVariationVectorInvalid,
   ProductVariationVectorAlreadySet,
+  ProductVariationInfinityLoop,
 } from '../../../errors.js';
 const extractVariationMatrix = (variations = []) => {
   const cartesianProduct = (arrays) => {
@@ -61,6 +62,8 @@ export default async function addProductAssignment(
   });
   if (!proxyProduct) throw new ProductNotFoundError({ proxyId });
 
+  if (productId === proxyId) throw new ProductVariationInfinityLoop({ productId });
+
   if (proxyProduct.type !== ProductTypes.ConfigurableProduct)
     throw new ProductWrongTypeError({
       proxyId,

package/src/resolvers/queries/filters/searchAssortments.ts

@@ -1,18 +1,13 @@
 import { Context } from '../../../context.js';
 import { SearchQuery } from '@unchainedshop/core-filters';
 import { log } from '@unchainedshop/logger';
-import { QueryStringRequiredError } from '../../../errors.js';
 
 export default async function searchAssortments(root: never, query: SearchQuery, context: Context) {
   const { services, userId, locale } = context;
-  const forceLiveCollection = false;
 
   log(`query search assortments ${JSON.stringify(query)}`, { userId });
 
-  if (!query.queryString && !query.assortmentIds?.length) throw new QueryStringRequiredError({});
-
   return services.filters.searchAssortments(query, {
-    forceLiveCollection,
     locale,
   });
 }

package/src/resolvers/queries/filters/searchProducts.ts

@@ -1,6 +1,5 @@
 import { log } from '@unchainedshop/logger';
 import { SearchFilterQuery } from '@unchainedshop/core-filters';
-import { QueryStringRequiredError } from '../../../errors.js';
 import { Context } from '../../../context.js';
 
 export default async function searchProducts(
@@ -16,7 +15,6 @@ export default async function searchProducts(
   context: Context,
 ) {
   const { modules, services, userId, locale } = context;
-  const forceLiveCollection = false;
   const { queryString, includeInactive, filterQuery, assortmentId, ignoreChildAssortments, ...rest } =
     query;
 
@@ -25,7 +23,6 @@ export default async function searchProducts(
   if (assortmentId) {
     const productIds = await modules.assortments.findProductIds({
       assortmentId,
-      forceLiveCollection,
       ignoreChildAssortments,
     });
     const filterIds = await modules.assortments.filters.findFilterIds({
@@ -33,14 +30,12 @@ export default async function searchProducts(
     });
     return services.filters.searchProducts(
       { queryString, includeInactive, filterQuery, productIds, filterIds, ...rest },
-      { forceLiveCollection, locale: locale },
+      { locale: locale },
     );
   }
 
-  if (!queryString) throw new QueryStringRequiredError({});
-
   return services.filters.searchProducts(
     { queryString, includeInactive, filterQuery, ...rest },
-    { forceLiveCollection, locale: locale },
+    { locale: locale },
   );
 }

package/src/roles/all.ts

@@ -101,6 +101,7 @@ export const all = (role, actions) => {
   role.allow(actions.viewTokens, () => false);
   role.allow(actions.viewStatistics, () => false);
   role.allow(actions.uploadUserAvatar, () => false);
+  role.allow(actions.uploadTempFile, () => false);
   role.allow(actions.impersonate, () => false);
 
   // special case: when doing a login mutation, the user is not logged in technically yet,

package/src/roles/index.ts

@@ -118,6 +118,7 @@ const actions: Record<string, string> = [
   'removeUser',
   'downloadFile',
   'uploadUserAvatar',
+  'uploadTempFile',
 ].reduce((oldValue, actionValue) => {
   const newValue = oldValue;
   newValue[actionValue] = actionValue;

package/src/roles/loggedIn.ts

@@ -248,4 +248,5 @@ export const loggedIn = (role: any, actions: Record<string, string>) => {
   role.allow(actions.confirmMediaUpload, () => true);
   role.allow(actions.downloadFile, isFileAccessible);
   role.allow(actions.uploadUserAvatar, canUpdateAvatar);
+  role.allow(actions.uploadTempFile, canUpdateAvatar);
 };

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

@@ -1 +0,0 @@
-{"version":3,"file":"mcpHandler.d.ts","sourceRoot":"","sources":["../../src/express/mcpHandler.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA4DzC,QAAA,MAAM,UAAU,EAAE,cAOjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/lib/express/mcpHandler.js

@@ -1,68 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
-import createMcpServer from '../mcp/index.js';
-// Map to store transports by session ID
-const transports = {};
-const handlePostRequest = async (req, res) => {
-    // Check for existing session ID
-    const sessionId = req.headers['mcp-session-id'];
-    let transport;
-    if (sessionId && transports[sessionId]) {
-        // Reuse existing transport
-        transport = transports[sessionId];
-    }
-    else if (!sessionId && isInitializeRequest(req.body)) {
-        // New initialization request
-        transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => randomUUID(),
-            onsessioninitialized: (sessionId) => {
-                // Store the transport by session ID
-                transports[sessionId] = transport;
-            },
-        });
-        // Clean up transport when closed
-        transport.onclose = () => {
-            if (transport.sessionId) {
-                delete transports[transport.sessionId];
-            }
-        };
-        const server = createMcpServer();
-        await server.connect(transport);
-    }
-    else {
-        // Invalid request
-        res.status(400).json({
-            jsonrpc: '2.0',
-            error: {
-                code: -32000,
-                message: 'Bad Request: No valid session ID provided',
-            },
-            id: null,
-        });
-        return;
-    }
-    // Handle the request
-    await transport.handleRequest(req, res, req.body);
-};
-// Reusable handler for GET and DELETE requests
-const handleSessionRequest = async (req, res) => {
-    const sessionId = req.headers['mcp-session-id'];
-    if (!sessionId || !transports[sessionId]) {
-        res.status(400).send('Invalid or missing session ID');
-        return;
-    }
-    const transport = transports[sessionId];
-    await transport.handleRequest(req, res);
-};
-const mcpHandler = (req, res, next) => {
-    if (req.method === 'POST') {
-        return handlePostRequest(req, res, next);
-    }
-    else if (req.method === 'GET' || req.method === 'DELETE') {
-        return handleSessionRequest(req, res, next);
-    }
-    res.status(405).send('Method Not Allowed');
-};
-export default mcpHandler;
-//# sourceMappingURL=mcpHandler.js.map

package/lib/express/mcpHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcpHandler.js","sourceRoot":"","sources":["../../src/express/mcpHandler.ts"],"names":[],"mappings":"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"}