@unchainedshop/api 4.0.0-rc.11 → 4.0.0-rc.13

package/src/mcp/utils/getNormalizedOrderDetails.ts

@@ -0,0 +1,77 @@
+import { OrderPricingSheet } from '@unchainedshop/core';
+import { Context } from '../../context.js';
+import { getNormalizedProductDetails } from './getNormalizedProductDetails.js';
+import { removeConfidentialServiceHashes } from '@unchainedshop/core-users';
+
+export async function getNormalizedOrderDetails(
+  { orderId, orderNumber }: { orderId?: string; orderNumber?: string },
+  context: Context,
+) {
+  const { modules, loaders } = context;
+  const order = await modules.orders.findOrder({ orderId, orderNumber });
+  if (!order) return null;
+  const positions = await modules.orders.positions.findOrderPositions({
+    orderId: order._id,
+  });
+  const payment = await modules.orders.payments.findOrderPayment({
+    orderPaymentId: order?.paymentId,
+  });
+  const delivery = await modules.orders.deliveries.findDelivery({
+    orderDeliveryId: order?.deliveryId,
+  });
+  const [
+    items,
+    user,
+    enrollments,
+    currency,
+    country,
+    supportedPaymentProviders,
+    supportedDeliveryProviders,
+    discounts,
+  ] = await Promise.all([
+    Promise.all(
+      positions.map(async ({ productId, ...position }) => ({
+        ...(await getNormalizedProductDetails(productId, context)),
+        ...position,
+      })),
+    ),
+    loaders.userLoader.load({ userId: order.userId }),
+    modules.enrollments.findEnrollment({
+      orderId: order._id,
+    }),
+    loaders.currencyLoader.load({ isoCode: order.currencyCode }),
+    loaders.countryLoader.load({ isoCode: order.countryCode }),
+    context.services.orders.supportedPaymentProviders({
+      order,
+    }),
+    context.services.orders.supportedDeliveryProviders({
+      order,
+    }),
+    modules.orders.discounts.findOrderDiscounts({ orderId: order._id }),
+  ]);
+  let total = null;
+  const pricing = OrderPricingSheet({
+    calculation: order.calculation,
+    currencyCode: order.currencyCode,
+  });
+
+  if (pricing.isValid()) {
+    total = pricing.total();
+  }
+
+  return {
+    ...order,
+    total,
+    discounts,
+    enrollments,
+    currency,
+    supportedDeliveryProviders,
+    supportedPaymentProviders,
+    country,
+    user: removeConfidentialServiceHashes(user),
+    status: order?.status ?? 'OPEN',
+    items,
+    payment,
+    delivery,
+  };
+}

package/src/mcp/utils/getNormalizedProductDetails.ts

@@ -15,12 +15,16 @@ export async function getNormalizedProductDetails(productId: string, context: Co
   let variations = [];
   let bundleItems = [];
   let assignments = [];
-  if (product.type === ProductTypes.ConfigurableProduct && product?.proxy?.assignments?.length) {
+  const reviews = await modules.products.reviews.findProductReviews({
+    productId,
+  });
+
+  if (product.type === ProductTypes.ConfigurableProduct) {
     variations = await context.modules.products.variations.findProductVariations({
-      productId: product._id,
+      productId: product?._id,
     });
     assignments = await Promise.all(
-      product?.proxy?.assignments?.map(async (assignment) => {
+      (product?.proxy?.assignments || [])?.map(async (assignment) => {
         const product = await loaders.productLoader.load({
           productId: assignment.productId,
         });
@@ -34,7 +38,7 @@ export async function getNormalizedProductDetails(productId: string, context: Co
         });
         return {
           assignment: {
-            ...assignment,
+            ...(assignment || {}),
             product: {
               ...product,
               media,
@@ -94,5 +98,6 @@ export async function getNormalizedProductDetails(productId: string, context: Co
     variations,
     bundleItems,
     pricing,
+    reviews,
   };
 }

package/src/mcp/utils/getNormalizedUserDetails.ts

@@ -0,0 +1,86 @@
+import { removeConfidentialServiceHashes, User } from '@unchainedshop/core-users';
+import { Context } from '../../context.js';
+import normalizeMediaUrl from './normalizeMediaUrl.js';
+
+const getPrimaryEmail = (user: User) => {
+  return (user.emails || []).toSorted(
+    (left, right) => Number(right.verified) - Number(left.verified),
+  )?.[0];
+};
+
+export async function getNormalizedUserDetails(userId: string, context: Context) {
+  const { modules, loaders } = context;
+  const user = await modules.users.findUserById(userId);
+  if (!user) return null;
+
+  const avatar = await loaders.fileLoader.load({
+    fileId: user.avatarId,
+  });
+  const normalizedAvatar = await normalizeMediaUrl([{ mediaId: avatar?._id }], context);
+
+  const primaryEmail = getPrimaryEmail(user);
+  const { profile } = user;
+  let name = primaryEmail?.address || user._id;
+  if (profile && profile.displayName && profile.displayName !== '') name = profile.displayName;
+
+  const walletAddresses =
+    user.services?.web3?.flatMap((service) => {
+      return service.verified ? [service.address] : [];
+    }) || [];
+
+  const tokens = await context.modules.warehousing.findTokensForUser({
+    userId: user._id,
+    walletAddresses,
+  });
+
+  const userLocale = await modules.users.userLocale(user);
+
+  const country = await loaders.countryLoader.load({
+    isoCode: userLocale.region,
+  });
+
+  const enrollments = await modules.enrollments.findEnrollments({
+    userId: user._id,
+  });
+
+  const language = await loaders.languageLoader.load({ isoCode: userLocale.language });
+  const orders = await modules.orders.findOrders({
+    userId: user._id,
+  });
+
+  const paymentCredentials = await modules.payment.paymentCredentials.findPaymentCredentials(
+    { userId: user._id },
+    {
+      sort: {
+        created: -1,
+      },
+    },
+  );
+
+  const quotations = await modules.quotations.findQuotations({
+    userId: user._id,
+  });
+
+  const reviews = await modules.products.reviews.findProductReviews({
+    authorId: user._id,
+  });
+  const safeUser = removeConfidentialServiceHashes(user);
+
+  return {
+    ...safeUser,
+    avatar: normalizedAvatar,
+    primaryEmail,
+    name,
+    isGuest: !!safeUser?.guest,
+    tokens,
+    country,
+    enrollments,
+    language,
+    orders,
+    paymentCredentials,
+    quotations,
+    webAuthnCredentials: user?.services?.webAuthn || [],
+    web3Addresses: user?.services?.web3 || [],
+    reviews,
+  };
+}

package/src/mcp/utils/normalizeMediaUrl.ts

@@ -3,19 +3,22 @@ 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, {});
+      medias
+        .map(async (media) => {
+          const file = await context.loaders.fileLoader.load({
+            fileId: media.mediaId,
+          });
+          if (!file) return null;
+          const fileUploadAdapter = getFileAdapter();
+          const url = await fileUploadAdapter.createDownloadURL(file);
+          file.url = context.modules.files.normalizeUrl(url, {});
 
-        return {
-          ...media,
-          file,
-        };
-      }),
+          return {
+            ...media,
+            file,
+          };
+        })
+        .filter(Boolean),
     );
 
     return normalizedMedias.filter(Boolean);

package/src/mcp/utils/sanitizeLocalizationEntityData.ts

@@ -0,0 +1,26 @@
+import {
+  LocalizationType,
+  LocalizationEntity,
+  LocalizationUpdateEntity,
+} from '../tools/localization/types.js';
+import validateIsoCode from './validateIsoCode.js';
+
+const sanitizeEntityData = (
+  localizationType: LocalizationType,
+  entity: LocalizationEntity | LocalizationUpdateEntity,
+) => {
+  const entityData = { ...entity };
+
+  if (localizationType !== 'CURRENCY') {
+    delete entityData.contractAddress;
+    delete entityData.decimals;
+  }
+
+  if (entityData.isoCode) {
+    entityData.isoCode = validateIsoCode(localizationType, entityData.isoCode);
+  }
+
+  return entityData;
+};
+
+export default sanitizeEntityData;

package/src/mcp/utils/sharedSchemas.ts

@@ -1,12 +1,98 @@
 import { z } from 'zod';
+import { SortDirection } from '@unchainedshop/utils';
 
-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(),
+const sortDirectionKeys = Object.keys(SortDirection) as [string, ...string[]];
+
+export const PaginationSchema = {
+  limit: z.number().int().min(1).max(100).optional().describe('Maximum number of results to return'),
+  offset: z.number().int().min(0).optional().describe('Number of results to skip for pagination'),
 };
 
+export const SortingSchema = {
+  sort: z
+    .array(
+      z.object({
+        key: z.string().describe('Field to sort by'),
+        value: z.enum(sortDirectionKeys).describe('Sort direction (ASC/DESC)'),
+      }),
+    )
+    .optional()
+    .describe('Array of sort options'),
+};
+
+export const SearchSchema = {
+  queryString: z.string().optional().describe('Search query string for text-based filtering'),
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe('Whether to include inactive/disabled items'),
+};
+
+export const LocalizationTextSchema = z.object({
+  locale: z
+    .string()
+    .min(2)
+    .describe(
+      'Locale code (e.g., "en-US", "de-CH") when a user provides locale make sure it exists in the system languages first. and if not prompt them to add the language before using it. if they provide a dialect at least base language should be registered in the system. if it does not exists prompt the user to add the language. NEVER add it automatically',
+    ),
+  title: z.string().min(1).describe('Localized title'),
+  subtitle: z.string().optional().describe('Optional localized subtitle'),
+});
+
 export const DateRangeSchema = {
-  from: z.string().datetime().optional(),
-  to: z.string().datetime().optional(),
+  from: z.string().datetime().optional().describe('Start date in ISO format'),
+  to: z.string().datetime().optional().describe('End date in ISO format'),
 };
+
+export const OrderFilterSchema = {
+  paymentProviderIds: z.array(z.string()).optional().describe('Filter by payment provider IDs'),
+  deliveryProviderIds: z.array(z.string()).optional().describe('Filter by delivery provider IDs'),
+  status: z
+    .array(z.enum(['PENDING', 'CONFIRMED', 'SHIPPED', 'DELIVERED', 'CANCELLED']))
+    .optional()
+    .describe('Filter by order statuses'),
+};
+
+export const EntityIdSchema = {
+  id: z.string().min(1).optional().describe('Entity ID'),
+};
+
+export const MediaUrlSchema = {
+  url: z.string().url().optional().describe('Media URL'),
+};
+
+export function createManagementSchema<T extends readonly string[]>(
+  actions: T,
+  additionalFields: Record<string, z.ZodType> = {},
+) {
+  return {
+    action: z.enum(actions as any).describe(`Management action: ${actions.join(', ')}`),
+    ...PaginationSchema,
+    ...SortingSchema,
+    ...SearchSchema,
+    ...additionalFields,
+  };
+}
+
+export function createMcpResponse(response) {
+  return {
+    content: [
+      {
+        type: 'text' as const,
+        text: JSON.stringify({ ...response }),
+      },
+    ],
+  };
+}
+
+export function createMcpErrorResponse(action: string, error: Error) {
+  return {
+    content: [
+      {
+        type: 'text' as const,
+        text: `Error in ${action.toLowerCase()}: ${error.message}`,
+      },
+    ],
+  };
+}

package/src/mcp/utils/validateIsoCode.ts

@@ -0,0 +1,25 @@
+import { LocalizationType } from '../tools/localization/types.js';
+
+const validateIsoCode = (localizationType: LocalizationType, isoCode: string): string => {
+  switch (localizationType) {
+    case 'COUNTRY':
+      if (isoCode.length !== 2) {
+        throw new Error('Country ISO code must be exactly 2 characters (ISO 3166-1 alpha-2)');
+      }
+      return isoCode.toUpperCase();
+    case 'CURRENCY':
+      if (isoCode.length !== 3) {
+        throw new Error('Currency ISO code must be exactly 3 characters (ISO 4217)');
+      }
+      return isoCode.toUpperCase();
+    case 'LANGUAGE':
+      if (isoCode.length < 2 || isoCode.length > 10) {
+        throw new Error('Language ISO code must be 2-10 characters (ISO 639-1/ISO 3166-1)');
+      }
+      return isoCode;
+    default:
+      return isoCode;
+  }
+};
+
+export default validateIsoCode;

package/src/resolvers/queries/delivery/deliveryInterfaces.ts

@@ -3,16 +3,20 @@ import { Context } from '../../../context.js';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 import { log } from '@unchainedshop/logger';
 
-export default function deliveryInterfaces(
+export default async function deliveryInterfaces(
   root: never,
   { type }: { type: DeliveryProviderType },
   { userId }: Context,
 ) {
   log(`query deliveryInterfaces ${type}`, { userId });
 
-  return DeliveryDirector.getAdapters({
-    adapterFilter: (Adapter) => Adapter.typeSupported(type),
-  }).map((Adapter) => ({
+  const allAdapters = await DeliveryDirector.getAdapters();
+
+  const filteredAdapters = type
+    ? allAdapters.filter((Adapter) => Adapter.typeSupported(type as DeliveryProviderType))
+    : allAdapters;
+
+  return filteredAdapters.map((Adapter) => ({
     _id: Adapter.key,
     label: Adapter.label,
     version: Adapter.version,

package/src/resolvers/queries/orders/orders.ts

@@ -2,50 +2,29 @@ import { log } from '@unchainedshop/logger';
 import { SortOption } from '@unchainedshop/utils';
 import { OrderQuery } from '@unchainedshop/core-orders';
 import { Context } from '../../../context.js';
-import { PaymentProviderType } from '@unchainedshop/core-payment';
-import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 
 export default async function orders(
   root: never,
   params: OrderQuery & { limit?: number; offset?: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
-  const { limit, offset, paymentProviderTypes, deliveryProviderTypes, ...restParams } = params;
+  const { limit, offset, paymentProviderIds, deliveryProviderIds, ...restParams } = params;
   log(`query orders: ${limit} ${offset}  ${restParams?.queryString || ''}`, { userId });
 
   const promises: Promise<any>[] = [];
 
-  let paymentProviderIds: string[] | undefined;
-  let deliveryProviderIds: string[] | undefined;
-
-  if (paymentProviderTypes?.length) {
-    promises.push(
-      modules.payment.paymentProviders
-        .findProviders({ type: { $in: paymentProviderTypes as PaymentProviderType[] } })
-        .then((providers) => (paymentProviderIds = providers.map((p) => p._id))),
-    );
-  }
-
-  if (deliveryProviderTypes?.length) {
-    promises.push(
-      modules.delivery
-        .findProviders({ type: { $in: deliveryProviderTypes as DeliveryProviderType[] } })
-        .then((providers) => (deliveryProviderIds = providers.map((p) => p._id))),
-    );
-  }
-
   await Promise.all(promises);
   const [orderPayments, orderDeliveries] = await Promise.all([
-    paymentProviderIds
+    paymentProviderIds?.length
       ? modules.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
       : [],
-    deliveryProviderIds
+    deliveryProviderIds?.length
       ? modules.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
       : [],
   ]);
   if (
-    (paymentProviderTypes?.length && !orderPayments.length) ||
-    (deliveryProviderTypes?.length && !orderDeliveries.length)
+    (paymentProviderIds?.length && !orderPayments.length) ||
+    (deliveryProviderIds?.length && !orderDeliveries.length)
   )
     return [];
   const paymentIds = orderPayments.map((p) => p._id);

package/src/resolvers/queries/orders/ordersCount.ts

@@ -1,50 +1,29 @@
 import { log } from '@unchainedshop/logger';
 import { OrderQuery } from '@unchainedshop/core-orders';
 import { Context } from '../../../context.js';
-import { PaymentProviderType } from '@unchainedshop/core-payment';
-import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 
 export default async function ordersCount(
   root: never,
   params: OrderQuery,
   { modules, userId }: Context,
 ) {
-  const { paymentProviderTypes, deliveryProviderTypes, ...restParams } = params;
+  const { paymentProviderIds, deliveryProviderIds, ...restParams } = params;
   log(`query ordersCount: ${params.includeCarts ? 'includeCart' : ''}`, { userId });
 
   const promises: Promise<any>[] = [];
 
-  let paymentProviderIds: string[] | undefined;
-  let deliveryProviderIds: string[] | undefined;
-
-  if (paymentProviderTypes?.length) {
-    promises.push(
-      modules.payment.paymentProviders
-        .findProviders({ type: { $in: paymentProviderTypes as PaymentProviderType[] } })
-        .then((providers) => (paymentProviderIds = providers.map((p) => p._id))),
-    );
-  }
-
-  if (deliveryProviderTypes?.length) {
-    promises.push(
-      modules.delivery
-        .findProviders({ type: { $in: deliveryProviderTypes as DeliveryProviderType[] } })
-        .then((providers) => (deliveryProviderIds = providers.map((p) => p._id))),
-    );
-  }
-
   await Promise.all(promises);
   const [orderPayments, orderDeliveries] = await Promise.all([
-    paymentProviderIds
+    paymentProviderIds?.length
       ? modules.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
       : [],
-    deliveryProviderIds
+    deliveryProviderIds?.length
       ? modules.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
       : [],
   ]);
   if (
-    (paymentProviderTypes?.length && !orderPayments.length) ||
-    (deliveryProviderTypes && !orderDeliveries.length)
+    (paymentProviderIds?.length && !orderPayments.length) ||
+    (deliveryProviderIds?.length && !orderDeliveries.length)
   )
     return 0;
   const paymentIds = orderPayments.map((p) => p._id);

package/src/resolvers/queries/payment/paymentInterfaces.ts

@@ -10,11 +10,15 @@ export default async function paymentInterfaces(
 ) {
   log(`query paymentInterfaces ${type}`, { userId });
 
-  return PaymentDirector.getAdapters()
-    .filter((Adapter) => Adapter.typeSupported(type))
-    .map((Adapter) => ({
-      _id: Adapter.key,
-      label: Adapter.label,
-      version: Adapter.version,
-    }));
+  const allAdapters = await PaymentDirector.getAdapters();
+
+  const filteredAdapters = type
+    ? allAdapters.filter((Adapter) => Adapter.typeSupported(type as PaymentProviderType))
+    : allAdapters;
+
+  return filteredAdapters.map((Adapter) => ({
+    _id: Adapter.key,
+    label: Adapter.label,
+    version: Adapter.version,
+  }));
 }

package/src/resolvers/queries/warehousing/warehousingInterfaces.ts

@@ -9,10 +9,12 @@ export default async function warehousingInterfaces(
   { userId }: Context,
 ) {
   log(`query warehousingInterfaces ${type}`, { userId });
+  const allAdapters = await WarehousingDirector.getAdapters();
+  const filteredAdapters = type
+    ? allAdapters.filter((Adapter) => Adapter.typeSupported(type as WarehousingProviderType))
+    : allAdapters;
 
-  return WarehousingDirector.getAdapters({
-    adapterFilter: (Adapter) => Adapter.typeSupported(type),
-  }).map((Adapter) => ({
+  return filteredAdapters.map((Adapter) => ({
     _id: Adapter.key,
     label: Adapter.label,
     version: Adapter.version,

package/src/schema/query.ts

@@ -181,7 +181,7 @@ export default [
       """
       Get all delivery interfaces filtered by type
       """
-      deliveryInterfaces(type: DeliveryProviderType!): [DeliveryInterface!]!
+      deliveryInterfaces(type: DeliveryProviderType): [DeliveryInterface!]!
         @cacheControl(scope: PRIVATE, maxAge: 0)
 
       """
@@ -205,7 +205,7 @@ export default [
       """
       Get all warehousing interfaces filtered by type
       """
-      warehousingInterfaces(type: WarehousingProviderType!): [WarehousingInterface!]!
+      warehousingInterfaces(type: WarehousingProviderType): [WarehousingInterface!]!
         @cacheControl(scope: PRIVATE, maxAge: 0)
 
       """
@@ -242,7 +242,7 @@ export default [
       """
       Get all payment interfaces filtered by type
       """
-      paymentInterfaces(type: PaymentProviderType!): [PaymentInterface!]!
+      paymentInterfaces(type: PaymentProviderType): [PaymentInterface!]!
         @cacheControl(scope: PRIVATE, maxAge: 0)
 
       """
@@ -251,8 +251,8 @@ export default [
       ordersCount(
         includeCarts: Boolean = false
         queryString: String
-        paymentProviderTypes: [PaymentProviderType!]
-        deliveryProviderTypes: [DeliveryProviderType!]
+        paymentProviderIds: [String!]
+        deliveryProviderIds: [String!]
         dateRange: DateFilterInput
         status: [OrderStatus!]
       ): Int!
@@ -267,8 +267,8 @@ export default [
         queryString: String
         status: [OrderStatus!]
         sort: [SortOptionInput!]
-        paymentProviderTypes: [PaymentProviderType!]
-        deliveryProviderTypes: [DeliveryProviderType!]
+        paymentProviderIds: [String!]
+        deliveryProviderIds: [String!]
         dateRange: DateFilterInput
       ): [Order!]!
 

package/lib/mcp/tools/assortment/addAssortmentFilterHandler.d.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-export declare const AddAssortmentFilterSchema: {
-    assortmentId: z.ZodString;
-    filterId: z.ZodString;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-};
-export declare const AddAssortmentFilterZodSchema: z.ZodObject<{
-    assortmentId: z.ZodString;
-    filterId: z.ZodString;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    tags?: string[];
-    assortmentId?: string;
-    filterId?: string;
-}, {
-    tags?: string[];
-    assortmentId?: string;
-    filterId?: string;
-}>;
-export type AddAssortmentFilterParams = z.infer<typeof AddAssortmentFilterZodSchema>;
-export declare function addAssortmentFilterHandler(context: Context, params: AddAssortmentFilterParams): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-//# sourceMappingURL=addAssortmentFilterHandler.d.ts.map

package/lib/mcp/tools/assortment/addAssortmentFilterHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addAssortmentFilterHandler.d.ts","sourceRoot":"","sources":["../../../../src/mcp/tools/assortment/addAssortmentFilterHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAM9C,eAAO,MAAM,yBAAyB;;;;CAWrC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAAsC,CAAC;AAEhF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAErF,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,yBAAyB;;;;;GAyCnG"}