@unchainedshop/api 4.0.0-rc.10 → 4.0.0-rc.12

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

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { WarehousingProviderNotFoundError } from '../../../errors.js';
+
+const ConfigurationEntry = z.object({
+  key: z.string().min(1).describe('Configuration key'),
+  value: z.any().describe('Configuration value'),
+});
+
+export const UpdateWarehousingProviderSchema = {
+  warehousingProviderId: z.string().min(1).describe('ID of the warehousing provider to update'),
+  warehousingProvider: z
+    .object({
+      configuration: z
+        .array(ConfigurationEntry)
+        .optional()
+        .describe('List of key-value configuration entries'),
+    })
+    .refine(
+      (data) => {
+        const keys = data.configuration?.map((entry) => entry.key) || [];
+        return new Set(keys).size === keys.length;
+      },
+      {
+        message: 'Duplicate keys are not allowed in configuration.',
+        path: ['configuration'],
+      },
+    ),
+};
+
+export const UpdateWarehousingProviderZodSchema = z.object(UpdateWarehousingProviderSchema);
+export type UpdateWarehousingProviderParams = z.infer<typeof UpdateWarehousingProviderZodSchema>;
+
+export async function updateWarehousingProviderHandler(
+  context: Context,
+  params: UpdateWarehousingProviderParams,
+) {
+  const { modules, userId } = context;
+  const { warehousingProviderId, warehousingProvider } = params;
+
+  try {
+    log('handler updateWarehousingProviderHandler', {
+      userId,
+      warehousingProviderId,
+      warehousingProvider,
+    });
+
+    if (!(await modules.warehousing.providerExists({ warehousingProviderId })))
+      throw new WarehousingProviderNotFoundError({ warehousingProviderId });
+
+    const provider = await modules.warehousing.update(warehousingProviderId, warehousingProvider as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ provider }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating warehousing provider: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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/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/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

@@ -8,11 +8,31 @@ export default async function orders(
   params: OrderQuery & { limit?: number; offset?: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
-  const { includeCarts, limit, offset, queryString } = params;
+  const { limit, offset, paymentProviderIds, deliveryProviderIds, ...restParams } = params;
+  log(`query orders: ${limit} ${offset}  ${restParams?.queryString || ''}`, { userId });
 
-  log(`query orders: ${limit} ${offset} ${includeCarts} ${queryString}`, {
-    userId,
-  });
+  const promises: Promise<any>[] = [];
+
+  await Promise.all(promises);
+  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 [];
+  const paymentIds = orderPayments.map((p) => p._id);
+  const deliveryIds = orderDeliveries.map((d) => d._id);
 
-  return modules.orders.findOrders(params);
+  return modules.orders.findOrders({
+    ...restParams,
+    paymentIds,
+    deliveryIds,
+  });
 }

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

@@ -7,7 +7,27 @@ export default async function ordersCount(
   params: OrderQuery,
   { modules, userId }: Context,
 ) {
+  const { paymentProviderIds, deliveryProviderIds, ...restParams } = params;
   log(`query ordersCount: ${params.includeCarts ? 'includeCart' : ''}`, { userId });
 
-  return modules.orders.count(params);
+  const promises: Promise<any>[] = [];
+
+  await Promise.all(promises);
+  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 0;
+  const paymentIds = orderPayments.map((p) => p._id);
+  const deliveryIds = orderDeliveries.map((d) => d._id);
+
+  return modules.orders.count({ ...restParams, paymentIds, deliveryIds });
 }

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,13 +242,20 @@ export default [
       """
       Get all payment interfaces filtered by type
       """
-      paymentInterfaces(type: PaymentProviderType!): [PaymentInterface!]!
+      paymentInterfaces(type: PaymentProviderType): [PaymentInterface!]!
         @cacheControl(scope: PRIVATE, maxAge: 0)
 
       """
       Returns total number of orders
       """
-      ordersCount(includeCarts: Boolean = false, queryString: String): Int!
+      ordersCount(
+        includeCarts: Boolean = false
+        queryString: String
+        paymentProviderIds: [String!]
+        deliveryProviderIds: [String!]
+        dateRange: DateFilterInput
+        status: [OrderStatus!]
+      ): Int!
 
       """
       Get all orders, by default sorted by creation date (descending)
@@ -260,6 +267,9 @@ export default [
         queryString: String
         status: [OrderStatus!]
         sort: [SortOptionInput!]
+        paymentProviderIds: [String!]
+        deliveryProviderIds: [String!]
+        dateRange: DateFilterInput
       ): [Order!]!
 
       """