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

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

@@ -0,0 +1,273 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { createAssortmentHandler, CreateAssortmentSchema } from './createAssortmentHandler.js';
+import { AddAssortmentFilterSchema, addAssortmentFilterHandler } from './addAssortmentFilterHandler.js';
+import { AddAssortmentLinkSchema, addAssortmentLinkHandler } from './addAssortmentLinkHandler.js';
+import {
+  AddAssortmentMediaUploadSchema,
+  addAssortmentMediaUploadHandler,
+} from './addAssortmentMediaUploadHandler.js';
+import {
+  AddAssortmentProductSchema,
+  addAssortmentProductHandler,
+} from './addAssortmentProductHandler.js';
+import { AssortmentChildrenSchema, assortmentChildrenHandler } from './assortmentChildrenHandler.js';
+import { AssortmentFiltersSchema, assortmentFiltersHandler } from './assortmentFiltersHandler.js';
+import { AssortmentSchema, assortmentHandler } from './assortmentHandler.js';
+import { AssortmentLinksSchema, assortmentLinksHandler } from './assortmentLinksHandler.js';
+import { AssortmentProductsSchema, assortmentProductsHandler } from './assortmentProductsHandler.js';
+import { AssortmentsCountSchema, assortmentsCountHandler } from './assortmentsCountHandler.js';
+import { AssortmentsSchema, assortmentsHandler } from './assortmentsHandler.js';
+import {
+  RemoveAssortmentFilterSchema,
+  removeAssortmentFilterHandler,
+} from './removeAssortmentFilterHandler.js';
+import { RemoveAssortmentSchema, removeAssortmentHandler } from './removeAssortmentHandler.js';
+import {
+  RemoveAssortmentLinkSchema,
+  removeAssortmentLinkHandler,
+} from './removeAssortmentLinkHandler.js';
+import {
+  RemoveAssortmentMediaSchema,
+  removeAssortmentMediaHandler,
+} from './removeAssortmentMediaHandler.js';
+import {
+  RemoveAssortmentProductSchema,
+  removeAssortmentProductHandler,
+} from './removeAssortmentProductHandler.js';
+import {
+  ReorderAssortmentFiltersSchema,
+  reorderAssortmentFiltersHandler,
+} from './reorderAssortmentFiltersHandler.js';
+import {
+  ReorderAssortmentLinksSchema,
+  reorderAssortmentLinksHandler,
+} from './reorderAssortmentLinksHandler.js';
+import {
+  ReorderAssortmentMediaSchema,
+  reorderAssortmentMediaHandler,
+} from './reorderAssortmentMediaHandler.js';
+import {
+  ReorderAssortmentProductsSchema,
+  reorderAssortmentProductsHandler,
+} from './reorderAssortmentProductsHandler.js';
+import {
+  SearchAssortmentProductSchema,
+  searchAssortmentProductHandler,
+} from './searchAssortmentProductHandler.js';
+import { SetBaseAssortmentSchema, setBaseAssortmentHandler } from './setBaseAssortmentHandler.js';
+import {
+  TranslatedAssortmentMediaTextsSchema,
+  translatedAssortmentMediaTextsHandler,
+} from './translatedAssortmentMediaTextsHandler.js';
+import {
+  TranslatedAssortmentTextsSchema,
+  translatedAssortmentTextsHandler,
+} from './translatedAssortmentTextsHandler.js';
+import { UpdateAssortmentSchema, updateAssortmentHandler } from './updateAssortmentHandler.js';
+import {
+  UpdateAssortmentMediaTextsSchema,
+  updateAssortmentMediaTextsHandler,
+} from './updateAssortmentMediaTextsHandler.js';
+import {
+  UpdateAssortmentTextsSchema,
+  updateAssortmentTextsHandler,
+} from './updateAssortmentTextsHandler.js';
+
+export const registerAssortmentTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'assortment_create',
+    'Create a new assortment with optional localized texts.',
+    CreateAssortmentSchema,
+    async (params) => createAssortmentHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_update',
+    'Update fields of an existing assortment by ID.',
+    UpdateAssortmentSchema,
+    async (params) => updateAssortmentHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_remove',
+    'Remove an assortment by ID.',
+    RemoveAssortmentSchema,
+    async (params) => removeAssortmentHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_setBase',
+    'Makes the provided assortment the base assortment and resets others to regular.',
+    SetBaseAssortmentSchema,
+    async (params) => setBaseAssortmentHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_get',
+    'Fetch details of an assortment by ID or slug.',
+    AssortmentSchema,
+    async (params) => assortmentHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_list',
+    'List assortments with filtering, pagination, and sorting options.',
+    AssortmentsSchema,
+    async (params) => assortmentsHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_count',
+    'Count assortments matching given filters.',
+    AssortmentsCountSchema,
+    async (params) => assortmentsCountHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_getChildren',
+    'Fetch child assortments for a given assortment ID (or root-level assortments if none is provided).',
+    AssortmentChildrenSchema,
+    async (params) => assortmentChildrenHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_getProducts',
+    'Fetch products for a given assortment, optionally including inactive ones.',
+    AssortmentProductsSchema,
+    async (params) => assortmentProductsHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_searchProducts',
+    'Search products within an assortment with optional filtering and pagination.',
+    SearchAssortmentProductSchema,
+    async (params) => searchAssortmentProductHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_getLinks',
+    'Fetch parent and child links for a given assortment_',
+    AssortmentLinksSchema,
+    async (params) => assortmentLinksHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_getFilters',
+    'Fetch filters associated with a specific assortment_',
+    AssortmentFiltersSchema,
+    async (params) => assortmentFiltersHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_addProduct',
+    'Add a product to an assortment with optional tags.',
+    AddAssortmentProductSchema,
+    async (params) => addAssortmentProductHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_removeProduct',
+    'Remove a product from an assortment_',
+    RemoveAssortmentProductSchema,
+    async (params) => removeAssortmentProductHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_reorderProducts',
+    'Reorder assortment products by assigning new sort keys.',
+    ReorderAssortmentProductsSchema,
+    async (params) => reorderAssortmentProductsHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_linkChild',
+    'Create a parent-child relationship between two assortments, with optional tags.',
+    AddAssortmentLinkSchema,
+    async (params) => addAssortmentLinkHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_removeLink',
+    'Remove a link between assortments by ID.',
+    RemoveAssortmentLinkSchema,
+    async (params) => removeAssortmentLinkHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_reorderLinks',
+    'Reorder assortment links by assigning new sort keys.',
+    ReorderAssortmentLinksSchema,
+    async (params) => reorderAssortmentLinksHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_reorderMedia',
+    'Reorder assortment media assets with new sorting keys; first item becomes primary media.',
+    ReorderAssortmentMediaSchema,
+    async (params) => reorderAssortmentMediaHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_addMedia',
+    'Upload and link a media asset (e.g., image or video) to an assortment_',
+    AddAssortmentMediaUploadSchema,
+    async (params) => addAssortmentMediaUploadHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_removeMedia',
+    'Remove a media asset previously attached to an assortment_',
+    RemoveAssortmentMediaSchema,
+    async (params) => removeAssortmentMediaHandler(context, params),
+  );
+
+  server.tool(
+    'assortmentMedia_updateTexts',
+    'Update localized texts for a specific assortment media asset.',
+    UpdateAssortmentMediaTextsSchema,
+    async (params) => updateAssortmentMediaTextsHandler(context, params),
+  );
+
+  server.tool(
+    'assortmentMedia_getTexts',
+    'Retrieve translated texts associated with a specific assortment media asset.',
+    TranslatedAssortmentMediaTextsSchema,
+    async (params) => translatedAssortmentMediaTextsHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_getTexts',
+    'Retrieve translated texts for a specific assortment_',
+    TranslatedAssortmentTextsSchema,
+    async (params) => translatedAssortmentTextsHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_updateTexts',
+    'Update localized texts (title, subtitle, description, slug) of an assortment for one or more locales.',
+    UpdateAssortmentTextsSchema,
+    async (params) => updateAssortmentTextsHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_addFilter',
+    'Attach a filter to a specific assortment, optionally tagging the relation.',
+    AddAssortmentFilterSchema,
+    async (params) => addAssortmentFilterHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_removeFilter',
+    'Remove a filter from an assortment_',
+    RemoveAssortmentFilterSchema,
+    async (params) => removeAssortmentFilterHandler(context, params),
+  );
+
+  server.tool(
+    'assortment_reorderFilters',
+    'Reorder assortment filters by assigning new sort keys.',
+    ReorderAssortmentFiltersSchema,
+    async (params) => reorderAssortmentFiltersHandler(context, params),
+  );
+};

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

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

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

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

@@ -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).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

@@ -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).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

@@ -0,0 +1,55 @@
+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 });
+
+    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}`,
+        },
+      ],
+    };
+  }
+}