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

package/src/mcp/tools/assortment/addAssortmentProductHandler.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentNotFoundError, ProductNotFoundError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+
+export const AddAssortmentProductSchema = {
+  assortmentId: z.string().min(1).describe('ID of the assortment to add the product to'),
+  productId: z.string().min(1).describe('ID of the product to add'),
+  tags: z
+    .array(z.string().min(1).toLowerCase())
+    .optional()
+    .describe('Optional tags to associate with this product inside the assortment'),
+};
+
+export const AddAssortmentProductZodSchema = z.object(AddAssortmentProductSchema);
+export type AddAssortmentProductParams = z.infer<typeof AddAssortmentProductZodSchema>;
+
+export async function addAssortmentProductHandler(context: Context, params: AddAssortmentProductParams) {
+  const { modules, userId } = context;
+  const { assortmentId, productId, tags } = params;
+  try {
+    log('mutation addAssortmentProduct', { userId, params });
+    const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+    if (!assortment)
+      throw new AssortmentNotFoundError({
+        assortmentId,
+      });
+    const product = await getNormalizedProductDetails(productId, context);
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    const assortmentProduct = await modules.assortments.products.create({
+      assortmentId,
+      productId,
+      tags,
+    } as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortmentProduct: { ...assortmentProduct, assortment, product } }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error adding product to assortment product: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/assortmentChildrenHandler.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+
+export const AssortmentChildrenSchema = {
+  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include inactive assortments'),
+};
+
+export const AssortmentChildrenZodSchema = z.object(AssortmentChildrenSchema);
+
+export type AssortmentChildrenParams = z.infer<typeof AssortmentChildrenZodSchema>;
+
+export async function assortmentChildrenHandler(context: Context, params: AssortmentChildrenParams) {
+  const { userId, modules } = context;
+  const { assortmentId, includeInactive } = params;
+
+  try {
+    log('handler assortmentChildren', { userId, params });
+    const assortmentChildren = await modules.assortments.children({
+      assortmentId,
+      includeInactive,
+    });
+
+    const normalizedAssortmentChildren = await Promise.all(
+      assortmentChildren.map(async ({ _id }) =>
+        getNormalizedAssortmentDetails({ assortmentId: _id }, context),
+      ),
+    );
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortments: normalizedAssortmentChildren }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting assortment children: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/assortmentFiltersHandler.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const AssortmentFiltersSchema = {
+  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+};
+
+export const AssortmentFiltersZodSchema = z.object(AssortmentFiltersSchema);
+
+export type AssortmentFiltersParams = z.infer<typeof AssortmentFiltersZodSchema>;
+
+export async function assortmentFiltersHandler(context: Context, params: AssortmentFiltersParams) {
+  const { userId, modules } = context;
+  const { assortmentId } = params;
+
+  try {
+    log('handler assortmentFilters', { userId, params });
+    const assortmentFilters = await modules.assortments.filters.findFilters(
+      {
+        assortmentId,
+      },
+      {
+        sort: { sortKey: 1 },
+      },
+    );
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ filters: assortmentFilters }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting assortment filters: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/assortmentHandler.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+
+export const AssortmentSchema = {
+  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+  slug: z.string().min(1).optional().describe('Slug of the assortment to fetch'),
+};
+
+export const AssortmentZodSchema = z
+  .object(AssortmentSchema)
+  .refine((data) => !!data.assortmentId || !!data.slug, {
+    message: 'Either assortmentId or slug must be provided.',
+  });
+
+export type AssortmentParams = z.infer<typeof AssortmentZodSchema>;
+
+export async function assortmentHandler(context: Context, params: AssortmentParams) {
+  const { userId } = context;
+  const { assortmentId, slug } = params;
+
+  try {
+    log('handler assortment', { userId, params });
+
+    const assortment = await getNormalizedAssortmentDetails(
+      {
+        assortmentId,
+        slug,
+      },
+      context,
+    );
+
+    if (!assortment) {
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: `Assortment not found  with ${assortmentId ? `ID: ${assortmentId}` : `slug: ${slug}`}`,
+          },
+        ],
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortment }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting assortment: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/assortmentLinksHandler.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+
+export const AssortmentLinksSchema = {
+  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+};
+
+export const AssortmentLinksZodSchema = z.object(AssortmentLinksSchema);
+
+export type AssortmentLinksParams = z.infer<typeof AssortmentLinksZodSchema>;
+
+export async function assortmentLinksHandler(context: Context, params: AssortmentLinksParams) {
+  const { userId, loaders } = context;
+  const { assortmentId } = params;
+
+  try {
+    log('handler assortmentLinks', { userId, params });
+    const assortmentLinks = await loaders.assortmentLinksLoader.load({
+      assortmentId,
+    });
+
+    const normalizedAssortmentLinks = await Promise.all(
+      assortmentLinks.map(async ({ parentAssortmentId, childAssortmentId, ...rest }) => {
+        const parent =
+          parentAssortmentId === assortmentId
+            ? null
+            : await getNormalizedAssortmentDetails({ assortmentId: parentAssortmentId }, context);
+        const child =
+          childAssortmentId === assortmentId
+            ? null
+            : await getNormalizedAssortmentDetails({ assortmentId: childAssortmentId }, context);
+
+        return {
+          ...rest,
+          parent,
+          child,
+        };
+      }),
+    );
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ links: normalizedAssortmentLinks }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting assortment links: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/assortmentProductsHandler.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+
+export const AssortmentProductsSchema = {
+  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include inactive assortments'),
+};
+
+export const AssortmentProductsZodSchema = z.object(AssortmentProductsSchema);
+
+export type AssortmentProductsParams = z.infer<typeof AssortmentProductsZodSchema>;
+
+export async function assortmentProductsHandler(context: Context, params: AssortmentProductsParams) {
+  const { userId, modules } = context;
+  const { assortmentId } = params;
+
+  try {
+    log('handler assortmentProducts', { userId, params });
+    const assortmentProducts = await modules.assortments.products.findAssortmentProducts(
+      {
+        assortmentId,
+      },
+      {
+        sort: { sortKey: 1 },
+      },
+    );
+
+    const normalizedAssortmentProducts = await Promise.all(
+      assortmentProducts.map(async ({ productId }) => getNormalizedProductDetails(productId, context)),
+    );
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ products: normalizedAssortmentProducts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting assortment children: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/assortmentsCountHandler.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const AssortmentsCountSchema = {
+  tags: z
+    .array(z.string().min(1).toLowerCase())
+    .optional()
+    .describe('Filter assortments by lowercase tags'),
+  slugs: z.array(z.string().min(1)).optional().describe('Filter assortments by slug(s)'),
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include inactive assortments'),
+  includeLeaves: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include leaf-level assortments'),
+  queryString: z.string().optional().describe('Free-text filter for matching assortments'),
+};
+
+export const AssortmentsCountZodSchema = z.object(AssortmentsCountSchema);
+export type AssortmentsCountParams = z.infer<typeof AssortmentsCountZodSchema>;
+
+export async function assortmentsCountHandler(context: Context, params: AssortmentsCountParams) {
+  const { modules, userId } = context;
+
+  try {
+    log('handler assortmentsCount', { userId, params });
+
+    const count = await modules.assortments.count(params);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify(count),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error counting assortments: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/assortmentsHandler.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+
+const SortDirectionEnum = z.enum(['ASC', 'DESC']);
+
+export const SortOptionInputSchema = z.object({
+  key: z.string().min(1).describe('Field to sort by'),
+  value: SortDirectionEnum.describe('Sort direction: ASC or DESC'),
+});
+
+export const AssortmentsSchema = {
+  queryString: z.string().optional().describe('Free-text filter for matching assortments'),
+  tags: z
+    .array(z.string().min(1).toLowerCase())
+    .optional()
+    .describe('Filter assortments by lowercase tags'),
+  slugs: z.array(z.string().min(1)).optional().describe('Filter assortments by slug(s)'),
+  limit: z.number().int().min(1).max(100).default(10).describe('Pagination limit'),
+  offset: z.number().int().min(0).default(0).describe('Pagination offset'),
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include inactive assortments'),
+  includeLeaves: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include leaf-level assortments'),
+  sort: z.array(SortOptionInputSchema).optional().describe('Sort options (default: sequence ascending)'),
+};
+
+export const AssortmentsZodSchema = z.object(AssortmentsSchema);
+export type AssortmentsParams = z.infer<typeof AssortmentsZodSchema>;
+
+export async function assortmentsHandler(context: Context, params: AssortmentsParams) {
+  const { modules, userId } = context;
+
+  try {
+    log('handler assortments', { userId, params });
+
+    const assortments = await modules.assortments.findAssortments(params as any);
+    const normalizedAssortments = await Promise.all(
+      assortments.map(async ({ _id }) => getNormalizedAssortmentDetails({ assortmentId: _id }, context)),
+    );
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortments: normalizedAssortments }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting assortments: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/createAssortmentHandler.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+
+export const AssortmentTextInputSchema = z.object({
+  locale: z
+    .string()
+    .min(1)
+    .describe(
+      'locale iso code like "en-US", "de-CH" use default defaultLanguageIsoCode in shop info if not explicitly provided. if language is explicitly provided check if it exists',
+    ),
+  slug: z.string().optional().describe('Optional slug for URL structure'),
+  title: z.string().optional().describe('Title of the assortment'),
+  subtitle: z.string().optional().describe('Optional subtitle'),
+  description: z.string().optional().describe('Optional description'),
+});
+
+export const CreateAssortmentInputSchema = z.object({
+  isRoot: z.boolean().optional().describe('Whether this assortment is a root assortment'),
+  tags: z
+    .array(z.string().min(1).toLowerCase())
+    .optional()
+    .describe('List of lowercase tags associated with the assortment'),
+});
+
+export const CreateAssortmentSchema = {
+  assortment: CreateAssortmentInputSchema,
+  texts: z.array(AssortmentTextInputSchema).optional(),
+};
+export const CreateAssortmentZodSchema = z.object(CreateAssortmentSchema);
+
+export type CreateAssortmentParams = z.infer<typeof CreateAssortmentZodSchema>;
+
+export async function createAssortmentHandler(context: Context, params: CreateAssortmentParams) {
+  const { modules, userId } = context;
+  const { assortment, texts } = params;
+
+  try {
+    log('handler createAssortment', { userId, params });
+
+    const newAssortment = await modules.assortments.create(assortment as any);
+
+    if (texts) {
+      await modules.assortments.texts.updateTexts(newAssortment._id, texts as any);
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            assortment: await getNormalizedAssortmentDetails(
+              { assortmentId: newAssortment._id },
+              context,
+            ),
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error creating assortment: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/removeAssortmentFilterHandler.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentFilterNotFoundError } from '../../../errors.js';
+
+export const RemoveAssortmentFilterSchema = {
+  assortmentFilterId: z.string().min(1).describe('ID of the assortment filter to remove'),
+};
+
+export const RemoveAssortmentFilterZodSchema = z.object(RemoveAssortmentFilterSchema);
+
+export type RemoveAssortmentFilterParams = z.infer<typeof RemoveAssortmentFilterZodSchema>;
+
+export async function removeAssortmentFilterHandler(
+  context: Context,
+  params: RemoveAssortmentFilterParams,
+) {
+  const { assortmentFilterId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler removeAssortmentFilter', { userId, assortmentFilterId });
+
+    const assortmentFilter = await modules.assortments.filters.findFilter({
+      assortmentFilterId,
+    });
+
+    if (!assortmentFilter) throw new AssortmentFilterNotFoundError({ assortmentFilterId });
+
+    await modules.assortments.filters.delete(assortmentFilterId);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortmentFilter }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing assortment filter: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/removeAssortmentHandler.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentNotFoundError } from '../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+
+export const RemoveAssortmentSchema = {
+  assortmentId: z.string().min(1).describe('ID of the assortment to remove'),
+};
+
+export const RemoveAssortmentZodSchema = z.object(RemoveAssortmentSchema);
+export type RemoveAssortmentParams = z.infer<typeof RemoveAssortmentZodSchema>;
+
+export async function removeAssortmentHandler(context: Context, params: RemoveAssortmentParams) {
+  const { modules, userId } = context;
+  const { assortmentId } = params;
+
+  try {
+    log('handler removeAssortment', { userId, assortmentId });
+
+    const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+    if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+    await modules.assortments.delete(assortmentId);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortment }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing assortment: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/removeAssortmentLinkHandler.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentLinkNotFoundError } from '../../../errors.js';
+
+export const RemoveAssortmentLinkSchema = {
+  assortmentLinkId: z.string().min(1).describe('ID of the assortment link to remove'),
+};
+
+export const RemoveAssortmentLinkZodSchema = z.object(RemoveAssortmentLinkSchema);
+
+export type RemoveAssortmentLinkParams = z.infer<typeof RemoveAssortmentLinkZodSchema>;
+
+export async function removeAssortmentLinkHandler(context: Context, params: RemoveAssortmentLinkParams) {
+  const { assortmentLinkId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler removeAssortmentLink: ${assortmentLinkId}`, { userId });
+
+    const assortmentLink = await modules.assortments.links.findLink({
+      assortmentLinkId,
+    });
+
+    if (!assortmentLink) throw new AssortmentLinkNotFoundError({ assortmentLinkId });
+
+    await modules.assortments.links.delete(assortmentLinkId);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortmentLink }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing assortment link: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}