@unchainedshop/api 4.0.0-rc.9 → 4.0.0

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

@@ -1,60 +0,0 @@
-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 products for (optional).'),
-  includeInactive: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe('Whether to include inactive products in the assortment.'),
-};
-
-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 assortmentProductsHandler', { 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

@@ -1,53 +0,0 @@
-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 assortmentsCountHandler', { 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

@@ -1,67 +0,0 @@
-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']);
-
-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 assortmentsHandler', { 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

@@ -1,71 +0,0 @@
-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 createAssortmentHandler', { 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

@@ -1,50 +0,0 @@
-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 removeAssortmentFilterHandler', { userId, params });
-
-    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

@@ -1,44 +0,0 @@
-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 removeAssortmentHandler', { userId, params });
-
-    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

@@ -1,47 +0,0 @@
-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 removeAssortmentLinkHandler`, { userId, params });
-
-    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

@@ -1,55 +0,0 @@
-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('Unique ID of the media asset to remove from the assortment.'),
-};
-
-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 removeAssortmentMediaHandler`, { userId, params });
-
-    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({
-            success: true,
-          }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error removing assortment media: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,49 +0,0 @@
-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 removeAssortmentProductHandler`, { userId, params });
-
-    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

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const ReorderAssortmentFilterInputSchema = z.object({
-  assortmentFilterId: z.string().min(1).describe('ID of the assortment filter to reorder'),
-  sortKey: z.number().int().describe('New sorting key for the filter'),
-});
-
-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 reorderAssortmentFiltersHandler', { userId, params });
-
-    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

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const ReorderAssortmentLinkInputSchema = z.object({
-  assortmentLinkId: z.string().min(1).describe('ID of the assortment link to reorder'),
-  sortKey: z.number().describe('New sorting key for the link'),
-});
-
-export const ReorderAssortmentLinksSchema = {
-  sortKeys: z
-    .array(ReorderAssortmentLinkInputSchema)
-    .min(1)
-    .describe('Array of assortmentLinkId with their new sort keys'),
-};
-
-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 reorderAssortmentLinksHandler', { userId, params });
-
-    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

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-import { Context } from '../../../context.js';
-import { log } from '@unchainedshop/logger';
-
-export const ReorderAssortmentMediaInputSchema = z.object({
-  assortmentMediaId: z.string().min(1).describe('ID of the assortment media to reorder'),
-  sortKey: z.number().describe('New sorting key for the media (lower means higher priority)'),
-});
-
-export const ReorderAssortmentMediaSchema = {
-  sortKeys: z
-    .array(ReorderAssortmentMediaInputSchema)
-    .min(1)
-    .describe(
-      'Array of assortmentMediaId with their new sort keys; the first item will be the primary media',
-    ),
-};
-
-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 reorderAssortmentMediaHandler', { userId, params });
-
-    const media = await modules.assortments.media.updateManualOrder({
-      sortKeys,
-    } as any);
-
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: JSON.stringify({ media }),
-        },
-      ],
-    };
-  } catch (error) {
-    return {
-      content: [
-        {
-          type: 'text' as const,
-          text: `Error reordering assortment media: ${(error as Error).message}`,
-        },
-      ],
-    };
-  }
-}