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

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}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentMediaNotFoundError } from '../../../errors.js';
+
+export const RemoveAssortmentMediaSchema = {
+  assortmentMediaId: z.string().min(1).describe('ID of the assortment media to remove'),
+};
+
+export const RemoveAssortmentMediaZodSchema = z.object(RemoveAssortmentMediaSchema);
+
+export type RemoveAssortmentMediaParams = z.infer<typeof RemoveAssortmentMediaZodSchema>;
+
+export async function removeAssortmentMediaHandler(
+  context: Context,
+  params: RemoveAssortmentMediaParams,
+) {
+  const { assortmentMediaId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler removeAssortmentMedia: ${assortmentMediaId}`, { userId });
+
+    const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
+      assortmentMediaId,
+    });
+    if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
+
+    await modules.files.delete(assortmentMedia.mediaId);
+    await modules.assortments.media.delete(assortmentMediaId);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortmentMedia }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing assortment media: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentProductNotFoundError } from '../../../errors.js';
+
+export const RemoveAssortmentProductSchema = {
+  assortmentProductId: z.string().min(1).describe('ID of the assortment product to remove'),
+};
+
+export const RemoveAssortmentProductZodSchema = z.object(RemoveAssortmentProductSchema);
+
+export type RemoveAssortmentProductParams = z.infer<typeof RemoveAssortmentProductZodSchema>;
+
+export async function removeAssortmentProductHandler(
+  context: Context,
+  params: RemoveAssortmentProductParams,
+) {
+  const { assortmentProductId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler removeAssortmentProduct: ${assortmentProductId}`, { userId });
+
+    const assortmentProduct = await modules.assortments.products.findAssortmentProduct({
+      assortmentProductId,
+    });
+    if (!assortmentProduct) throw new AssortmentProductNotFoundError({ assortmentProductId });
+
+    await modules.assortments.products.delete(assortmentProductId);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortmentProduct }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing assortment product: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const ReorderAssortmentFilterInputSchema = z.object({
+  assortmentFilterId: z.string().min(1),
+  sortKey: z.number().int(),
+});
+
+export const ReorderAssortmentFiltersSchema = {
+  sortKeys: z
+    .array(ReorderAssortmentFilterInputSchema)
+    .min(1)
+    .describe('Array of assortmentFilterId and their new sort keys'),
+};
+
+export const ReorderAssortmentFiltersZodSchema = z.object(ReorderAssortmentFiltersSchema);
+
+export type ReorderAssortmentFiltersParams = z.infer<typeof ReorderAssortmentFiltersZodSchema>;
+
+export async function reorderAssortmentFiltersHandler(
+  context: Context,
+  params: ReorderAssortmentFiltersParams,
+) {
+  const { sortKeys } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler reorderAssortmentFilters', { userId, sortKeys });
+
+    await modules.assortments.filters.updateManualOrder({
+      sortKeys,
+    } as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ success: true }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error reordering assortment filters: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const ReorderAssortmentLinkInputSchema = z.object({
+  assortmentLinkId: z.string().min(1),
+  sortKey: z.number(),
+});
+
+export const ReorderAssortmentLinksSchema = {
+  sortKeys: z
+    .array(ReorderAssortmentLinkInputSchema)
+    .min(1)
+    .describe('New sort order for assortment links'),
+};
+
+export const ReorderAssortmentLinksZodSchema = z.object(ReorderAssortmentLinksSchema);
+
+export type ReorderAssortmentLinksParams = z.infer<typeof ReorderAssortmentLinksZodSchema>;
+
+export async function reorderAssortmentLinksHandler(
+  context: Context,
+  params: ReorderAssortmentLinksParams,
+) {
+  const { sortKeys } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler reorderAssortmentLinks', { userId, sortKeys });
+
+    await modules.assortments.links.updateManualOrder({
+      sortKeys: sortKeys,
+    } as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ success: true }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error reordering assortment links: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const ReorderAssortmentMediaInputSchema = z.object({
+  assortmentMediaId: z.string().min(1),
+  sortKey: z.number(),
+});
+
+export const ReorderAssortmentMediaSchema = {
+  sortKeys: z
+    .array(ReorderAssortmentMediaInputSchema)
+    .min(1)
+    .describe('New sort order for assortment media (first is primary)'),
+};
+
+export const ReorderAssortmentMediaZodSchema = z.object(ReorderAssortmentMediaSchema);
+
+export type ReorderAssortmentMediaParams = z.infer<typeof ReorderAssortmentMediaZodSchema>;
+
+export async function reorderAssortmentMediaHandler(
+  context: Context,
+  params: ReorderAssortmentMediaParams,
+) {
+  const { sortKeys } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler reorderAssortmentMedia', { userId, sortKeys });
+
+    await modules.assortments.media.updateManualOrder({
+      sortKeys,
+    } as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ success: true }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error reordering assortment media: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const ReorderAssortmentProductInputSchema = z.object({
+  assortmentProductId: z.string().min(1),
+  sortKey: z.number(),
+});
+
+export const ReorderAssortmentProductsSchema = {
+  sortKeys: z
+    .array(ReorderAssortmentProductInputSchema)
+    .min(1)
+    .describe('New sort order for assortment products'),
+};
+
+export const ReorderAssortmentProductsZodSchema = z.object(ReorderAssortmentProductsSchema);
+
+export type ReorderAssortmentProductsParams = z.infer<typeof ReorderAssortmentProductsZodSchema>;
+
+export async function reorderAssortmentProductsHandler(
+  context: Context,
+  params: ReorderAssortmentProductsParams,
+) {
+  const { sortKeys } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler reorderAssortmentProducts', { userId, sortKeys });
+
+    await modules.assortments.products.updateManualOrder({
+      sortKeys,
+    } as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ success: true }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error reordering assortment products: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const SearchAssortmentProductSchema = {
+  assortmentId: z.string().min(1).describe('ID of the assortment to search in'),
+  queryString: z.string().optional().describe('Search query string'),
+  filterQuery: z
+    .array(z.object({ key: z.string(), value: z.string().optional() }))
+    .optional()
+    .describe('Filter conditions'),
+  includeInactive: z.boolean().optional().default(true),
+  ignoreChildAssortments: z.boolean().optional().default(false),
+  limit: z.number().int().min(1).max(100).default(20).describe('Pagination limit'),
+  offset: z.number().int().min(0).default(0).describe('Pagination offset'),
+};
+
+export const SearchAssortmentProductZodSchema = z.object(SearchAssortmentProductSchema);
+
+export type SearchAssortmentProductParams = z.infer<typeof SearchAssortmentProductZodSchema>;
+
+export async function searchAssortmentProductHandler(
+  context: Context,
+  params: SearchAssortmentProductParams,
+) {
+  const { userId, modules, services, locale } = context;
+  const { assortmentId, limit, offset, ...query } = params;
+
+  try {
+    log('handler searchAssortmentProduct', { userId, params });
+
+    const productIds = await modules.assortments.findProductIds({
+      assortmentId,
+      ignoreChildAssortments: query.ignoreChildAssortments,
+    });
+
+    const filterIds = await modules.assortments.filters.findFilterIds({
+      assortmentId,
+    });
+    const result = await services.filters.searchProducts({ ...query, productIds, filterIds } as any, {
+      locale: locale,
+    });
+    const productsCount = await modules.products.search.countFilteredProducts({
+      productSelector: result.searchConfiguration.productSelector,
+      productIds: result.aggregatedTotalProductIds,
+    });
+    const products = await modules.products.search.findFilteredProducts({
+      limit,
+      offset,
+      productIds: result.aggregatedFilteredProductIds,
+      productSelector: result.searchConfiguration.productSelector,
+      sort: result.searchConfiguration.sortStage,
+    });
+
+    const relevantProductIds = await modules.products.findProductIds({
+      productSelector: result.searchConfiguration.productSelector,
+      productIds: result.totalProductIds,
+      includeDrafts: result.searchConfiguration.searchQuery.includeInactive,
+    });
+    const filters = await services.filters.loadFilters(result.searchConfiguration.searchQuery, {
+      productIds: relevantProductIds,
+      forceLiveCollection: result.searchConfiguration.forceLiveCollection,
+    });
+    const filteredProductsCount = await modules.products.search.countFilteredProducts({
+      productSelector: result.searchConfiguration.productSelector,
+      productIds: result.aggregatedFilteredProductIds,
+    });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ productsCount, products, filters, filteredProductsCount }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error searching products: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+import { AssortmentNotFoundError } from '../../../errors.js';
+
+export const SetBaseAssortmentSchema = {
+  assortmentId: z.string().min(1).describe('ID of the assortment to set as base'),
+};
+
+export const SetBaseAssortmentZodSchema = z.object(SetBaseAssortmentSchema);
+export type SetBaseAssortmentParams = z.infer<typeof SetBaseAssortmentZodSchema>;
+
+export async function setBaseAssortmentHandler(context: Context, params: SetBaseAssortmentParams) {
+  const { modules, userId } = context;
+  const { assortmentId } = params;
+
+  try {
+    log('handler setBaseAssortment', { userId, assortmentId });
+
+    if (!(await modules.assortments.assortmentExists({ assortmentId })))
+      throw new AssortmentNotFoundError({ assortmentId });
+
+    await modules.assortments.setBase(assortmentId);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            assortment: await getNormalizedAssortmentDetails({ assortmentId }, context),
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error setting base assortment: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}