@unchainedshop/api 3.1.15 → 4.0.0-rc.11

package/src/mcp/tools/warehousing/warehousingInterfacesHandler.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { WarehousingDirector } from '@unchainedshop/core';
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+
+const WarehousingProviderTypeEnum = z
+  .enum(['PHYSICAL', 'VIRTUAL'])
+  .describe('Warehousing provider type');
+
+export const WarehousingInterfacesSchema = {
+  type: WarehousingProviderTypeEnum.optional().describe('Optional filter by warehousing provider type'),
+};
+
+export const WarehousingInterfacesZodSchema = z.object(WarehousingInterfacesSchema);
+export type WarehousingInterfacesParams = z.infer<typeof WarehousingInterfacesZodSchema>;
+
+export async function warehousingInterfacesHandler(
+  context: Context,
+  params: WarehousingInterfacesParams,
+) {
+  const { userId } = context;
+  const { type } = params;
+
+  try {
+    log('handler warehousingInterfacesHandler', { userId, type });
+
+    const allAdapters = await WarehousingDirector.getAdapters();
+
+    const filteredAdapters = type
+      ? allAdapters.filter((Adapter) => Adapter.typeSupported(type as WarehousingProviderType))
+      : allAdapters;
+
+    const interfaces = filteredAdapters.map((Adapter) => ({
+      _id: Adapter.key,
+      label: Adapter.label,
+      version: Adapter.version,
+    }));
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ interfaces }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error fetching warehousing interfaces: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/warehousing/warehousingProviderHandler.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const WarehousingProviderByIdSchema = {
+  warehousingProviderId: z.string().min(1).describe('ID of the warehousing provider'),
+};
+
+export const WarehousingProviderByIdZodSchema = z.object(WarehousingProviderByIdSchema);
+export type WarehousingProviderByIdParams = z.infer<typeof WarehousingProviderByIdZodSchema>;
+
+export async function warehousingProviderHandler(
+  context: Context,
+  params: WarehousingProviderByIdParams,
+) {
+  const { modules, userId } = context;
+  const { warehousingProviderId } = params;
+
+  try {
+    log('handler warehousingProviderHandler', { userId, warehousingProviderId });
+
+    const provider = await modules.warehousing.findProvider({
+      warehousingProviderId,
+    });
+
+    if (!provider) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Warehousing provider not found for ID: ${warehousingProviderId}`,
+          },
+        ],
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ provider }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error fetching warehousing provider: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/warehousing/warehousingProvidersCountHandler.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+const WarehousingProviderTypeEnum = z
+  .enum(['PHYSICAL', 'VIRTUAL'])
+  .describe('Warehousing provider type');
+
+export const WarehousingProvidersCountSchema = {
+  type: WarehousingProviderTypeEnum.optional(),
+};
+
+export const WarehousingProvidersCountZodSchema = z.object(WarehousingProvidersCountSchema);
+export type WarehousingProvidersCountParams = z.infer<typeof WarehousingProvidersCountZodSchema>;
+
+export async function warehousingProvidersCountHandler(
+  context: Context,
+  params: WarehousingProvidersCountParams,
+) {
+  const { modules, userId } = context;
+  const { type } = params;
+
+  try {
+    log('handler warehousingProvidersCountHandler', { userId, type });
+
+    const count = await modules.warehousing.count(params as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ count }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error counting warehousing providers: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/warehousing/warehousingProvidersListHandler.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+const WarehousingProviderTypeEnum = z
+  .enum(['PHYSICAL', 'VIRTUAL'])
+  .describe('Warehousing provider type');
+
+export const WarehousingProvidersListSchema = {
+  type: WarehousingProviderTypeEnum.optional().describe('Optional filter by provider type'),
+  queryString: z.string().min(1).optional().describe('Search by _id or adapterKey (partial match)'),
+};
+
+export const WarehousingProvidersListZodSchema = z.object(WarehousingProvidersListSchema);
+export type WarehousingProvidersListParams = z.infer<typeof WarehousingProvidersListZodSchema>;
+
+export async function warehousingProvidersListHandler(
+  context: Context,
+  params: WarehousingProvidersListParams,
+) {
+  const { modules, userId } = context;
+  const { type, queryString } = params;
+
+  try {
+    log('handler warehousingProvidersListHandler', { userId, type, queryString });
+
+    const selector: Record<string, any> = {};
+    if (type) selector.type = type;
+
+    if (queryString) {
+      const regex = new RegExp(queryString, 'i');
+      selector.$or = [{ _id: regex }, { adapterKey: regex }];
+    }
+
+    const providers = await modules.warehousing.findProviders(selector);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ providers }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error fetching warehousing providers: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/utils/getNormalizedAssortmentDetails.ts

@@ -0,0 +1,40 @@
+import { Context } from '../../context.js';
+import normalizeMediaUrl from './normalizeMediaUrl.js';
+
+export async function getNormalizedAssortmentDetails(
+  { assortmentId, slug }: { assortmentId?: string; slug?: string },
+  context: Context,
+) {
+  const { modules, locale, loaders } = context;
+  const assortment = await modules.assortments.findAssortment({ assortmentId, slug });
+  const normalizedAssortmentId = assortmentId || assortment._id;
+  if (!assortment) return null;
+
+  const texts = await loaders.assortmentTextLoader.load({
+    assortmentId: normalizedAssortmentId,
+    locale,
+  });
+
+  const assortmentMedias = await modules.assortments.media.findAssortmentMedias({
+    assortmentId: normalizedAssortmentId,
+  });
+  const assortmentChildLinks = await loaders.assortmentLinksLoader.load({
+    parentAssortmentId: assortment._id,
+  });
+
+  const assortmentIds = assortmentChildLinks.map(({ childAssortmentId }) => childAssortmentId);
+
+  const childrenCount = await modules.assortments.count({
+    assortmentIds,
+    includeInactive: true,
+    includeLeaves: true,
+  });
+  const media = await normalizeMediaUrl(assortmentMedias, context);
+
+  return {
+    ...assortment,
+    texts,
+    media,
+    childrenCount,
+  };
+}

package/src/mcp/utils/getNormalizedFilterDetails.ts

@@ -0,0 +1,23 @@
+import { Context } from '../../context.js';
+
+export async function getNormalizedFilterDetails(filterId: string, context: Context) {
+  const { modules, locale, loaders } = context;
+  const filter = await modules.filters.findFilter({ filterId });
+
+  const texts = await loaders.filterTextLoader.load({
+    filterId,
+    filterOptionValue: null,
+    locale,
+  });
+
+  const options = await (filter.options || []).map((filterOption) => ({
+    ...filter,
+    filterOption,
+  }));
+
+  return {
+    ...filter,
+    options,
+    texts,
+  };
+}

package/src/mcp/utils/getNormalizedProductDetails.ts

@@ -0,0 +1,98 @@
+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 = [];
+  let bundleItems = [];
+  let assignments = [];
+  if (product.type === ProductTypes.ConfigurableProduct && product?.proxy?.assignments?.length) {
+    variations = await context.modules.products.variations.findProductVariations({
+      productId: product._id,
+    });
+    assignments = await Promise.all(
+      product?.proxy?.assignments?.map(async (assignment) => {
+        const product = await loaders.productLoader.load({
+          productId: assignment.productId,
+        });
+        const productMedias = await modules.products.media.findProductMedias({
+          productId: assignment.productId,
+        });
+        const media = await normalizeMediaUrl(productMedias, context);
+        const texts = await loaders.productTextLoader.load({
+          productId: assignment.productId,
+          locale,
+        });
+        return {
+          assignment: {
+            ...assignment,
+            product: {
+              ...product,
+              media,
+              texts,
+            },
+          },
+        };
+      }),
+    );
+  }
+
+  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 {
+    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,
+    assignments,
+    variations,
+    bundleItems,
+    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/mcp/utils/orderFilters.ts

@@ -0,0 +1,52 @@
+import { Context } from '../../context.js';
+
+export const resolveOrderFilters = async (
+  modules: Context['modules'],
+  {
+    paymentProviderIds,
+    deliveryProviderIds,
+  }: {
+    paymentProviderIds?: string[];
+    deliveryProviderIds?: string[];
+  },
+) => {
+  const [orderPayments, orderDeliveries] = await Promise.all([
+    paymentProviderIds?.length
+      ? modules.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
+      : [],
+    deliveryProviderIds?.length
+      ? modules.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
+      : [],
+  ]);
+
+  if (
+    (paymentProviderIds?.length && !orderPayments.length) ||
+    (deliveryProviderIds?.length && !orderDeliveries.length)
+  ) {
+    return null;
+  }
+
+  return {
+    paymentIds: orderPayments.map((p) => p._id),
+    deliveryIds: orderDeliveries.map((d) => d._id),
+  };
+};
+
+export const formatSummaryMap = (
+  map: Map<string, { sales: number; orders: number }>,
+): { date: string; sales: number; orders: number; avgOrderValue: number }[] => {
+  return Array.from(map.entries())
+    .reverse()
+    .map(([date, { sales, orders }]) => ({
+      date,
+      sales: Number(sales.toFixed(2)),
+      orders,
+      avgOrderValue: orders > 0 ? Math.round(sales / orders) : 0,
+    }));
+};
+
+export const resolveDateRange = (from?: string, to?: string, fallbackDays = 30) => {
+  const endDate = to ? new Date(to) : new Date();
+  const startDate = from ? new Date(from) : new Date(endDate.getTime() - (fallbackDays - 1) * 86400000);
+  return { startDate, endDate };
+};

package/src/mcp/utils/sharedSchemas.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const OrderFilterSchema = {
+  paymentProviderIds: z.array(z.string()).optional(),
+  deliveryProviderIds: z.array(z.string()).optional(),
+  status: z.array(z.enum(['PENDING', 'CONFIRMED', 'SHIPPED', 'DELIVERED', 'CANCELLED'])).optional(),
+};
+
+export const DateRangeSchema = {
+  from: z.string().datetime().optional(),
+  to: z.string().datetime().optional(),
+};

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

@@ -24,25 +24,29 @@ export default async function createUser(root: never, params: UserRegistrationDa
   }
 
   try {
+    const usersCountBeforeCreation = await context.modules.users.count({
+      includeDeleted: true,
+      includeGuests: true,
+    });
+
     const newUserId = await modules.users.createUser(
       {
         ...params,
         initialPassword: false,
+        roles: usersCountBeforeCreation === 0 ? ['admin'] : [],
       },
       {},
     );
 
-    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, {

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

@@ -17,17 +17,15 @@ export default async function loginAsGuest(root: never, _: any, context: Context
     { skipMessaging: true },
   );
 
-  let user = await context.modules.users.findUserById(guestUserId);
-
-  user = await context.modules.users.updateHeartbeat(user._id, {
+  const user = await context.modules.users.updateHeartbeat(guestUserId, {
     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);
 }

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

@@ -36,15 +36,15 @@ export default async function loginWithPassword(
     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,
   });
 
   if (context.userId) {
     await context.services.users.migrateUserData(context.userId, user._id);
   }
 
-  await context.services.orders.nextUserCart({ user, countryCode: context.countryContext });
+  await context.services.orders.nextUserCart({ user, countryCode: context.countryCode });
 
   return context.login(user);
 }

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

@@ -29,15 +29,15 @@ export default async function loginWithWebAuthn(
     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,
   });
 
   if (context.userId) {
     await context.services.users.migrateUserData(context.userId, user._id);
   }
 
-  await context.services.orders.nextUserCart({ user, countryCode: context.countryContext });
+  await context.services.orders.nextUserCart({ user, countryCode: context.countryCode });
 
   return context.login(user);
 }

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

@@ -19,15 +19,15 @@ export default async function resetPassword(
       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,
     });
 
     if (context.userId) {
       await context.services.users.migrateUserData(context.userId, user._id);
     }
 
-    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/stopImpersonation.ts

@@ -17,7 +17,7 @@ export default async function stopImpersonation(root: never, _, context: Context
 
   await context.services.orders.nextUserCart({
     user: impersonator,
-    countryCode: context.countryContext,
+    countryCode: context.countryCode,
   });
 
   return context.login(impersonator);

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

@@ -19,15 +19,15 @@ export default async function verifyEmail(root: never, { token }: { token: any }
     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,
   });
 
   if (context.userId) {
     await context.services.users.migrateUserData(context.userId, user._id);
   }
 
-  await context.services.orders.nextUserCart({ user, countryCode: context.countryContext });
+  await context.services.orders.nextUserCart({ user, countryCode: context.countryCode });
 
   return context.login(user);
 }

package/src/resolvers/mutations/assortments/reorderAssortmentFilters.ts

@@ -3,7 +3,7 @@ import { Context } from '../../../context.js';
 
 export default async function reorderAssortmentFilters(
   root: never,
-  params: { sortKeys: Array<{ assortmentFilterId: string; sortKey: number }> },
+  params: { sortKeys: { assortmentFilterId: string; sortKey: number }[] },
   { modules, userId }: Context,
 ) {
   log('mutation reorderAssortmentFilters', { userId });

package/src/resolvers/mutations/assortments/reorderAssortmentLinks.ts

@@ -3,7 +3,7 @@ import { Context } from '../../../context.js';
 
 export default async function reorderAssortmentLinks(
   root: never,
-  params: { sortKeys: Array<{ assortmentLinkId: string; sortKey: number }> },
+  params: { sortKeys: { assortmentLinkId: string; sortKey: number }[] },
   { modules, userId }: Context,
 ) {
   log('mutation reorderAssortmentLinks', { userId });

package/src/resolvers/mutations/assortments/reorderAssortmentMedia.ts

@@ -3,7 +3,7 @@ import { Context } from '../../../context.js';
 
 export default async function reorderAssortmentMedia(
   root: never,
-  params: { sortKeys: Array<{ assortmentMediaId: string; sortKey: number }> },
+  params: { sortKeys: { assortmentMediaId: string; sortKey: number }[] },
   { modules, userId }: Context,
 ) {
   log('mutation reorderAssortmentMedia', { userId });

package/src/resolvers/mutations/assortments/reorderAssortmentProducts.ts

@@ -3,7 +3,7 @@ import { Context } from '../../../context.js';
 
 export default async function reorderAssortmentProducts(
   root: never,
-  params: { sortKeys: Array<{ assortmentProductId: string; sortKey: number }> },
+  params: { sortKeys: { assortmentProductId: string; sortKey: number }[] },
   { modules, userId }: Context,
 ) {
   log('mutation reorderAssortmentProducts', { userId });