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

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/orders/orders.ts

@@ -2,17 +2,58 @@ 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 { includeCarts, limit, offset, queryString } = params;
+  const { limit, offset, paymentProviderTypes, deliveryProviderTypes, ...restParams } = params;
+  log(`query orders: ${limit} ${offset}  ${restParams?.queryString || ''}`, { userId });
 
-  log(`query orders: ${limit} ${offset} ${includeCarts} ${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))),
+    );
+  }
 
-  return modules.orders.findOrders(params);
+  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
+      ? modules.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
+      : [],
+    deliveryProviderIds
+      ? modules.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
+      : [],
+  ]);
+  if (
+    (paymentProviderTypes?.length && !orderPayments.length) ||
+    (deliveryProviderTypes?.length && !orderDeliveries.length)
+  )
+    return [];
+  const paymentIds = orderPayments.map((p) => p._id);
+  const deliveryIds = orderDeliveries.map((d) => d._id);
+
+  return modules.orders.findOrders({
+    ...restParams,
+    paymentIds,
+    deliveryIds,
+  });
 }

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

@@ -1,13 +1,54 @@
 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;
   log(`query ordersCount: ${params.includeCarts ? 'includeCart' : ''}`, { userId });
 
-  return modules.orders.count(params);
+  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
+      ? modules.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
+      : [],
+    deliveryProviderIds
+      ? modules.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
+      : [],
+  ]);
+  if (
+    (paymentProviderTypes?.length && !orderPayments.length) ||
+    (deliveryProviderTypes && !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/schema/query.ts

@@ -248,7 +248,14 @@ export default [
       """
       Returns total number of orders
       """
-      ordersCount(includeCarts: Boolean = false, queryString: String): Int!
+      ordersCount(
+        includeCarts: Boolean = false
+        queryString: String
+        paymentProviderTypes: [PaymentProviderType!]
+        deliveryProviderTypes: [DeliveryProviderType!]
+        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!]
+        paymentProviderTypes: [PaymentProviderType!]
+        deliveryProviderTypes: [DeliveryProviderType!]
+        dateRange: DateFilterInput
       ): [Order!]!
 
       """