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

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentNotFoundError, FilterNotFoundError } from '../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
+import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
+
+export const AddAssortmentFilterSchema = {
+  assortmentId: z.string().min(1).describe('ID of the assortment'),
+  filterId: z.string().min(1).describe('ID of the filter to add'),
+  tags: z
+    .array(z.string().regex(/^[a-z0-9-_]+$/))
+    .optional()
+    .describe('Optional lowercase tags'),
+};
+
+export const AddAssortmentFilterZodSchema = z.object(AddAssortmentFilterSchema);
+
+export type AddAssortmentFilterParams = z.infer<typeof AddAssortmentFilterZodSchema>;
+
+export async function addAssortmentFilterHandler(context: Context, params: AddAssortmentFilterParams) {
+  const { assortmentId, filterId, tags = [] } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler addAssortmentFilter', { userId, assortmentId, filterId, tags });
+    const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+    if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+    const filter = await getNormalizedFilterDetails(filterId, context);
+    if (!filter) throw new FilterNotFoundError({ filterId });
+
+    const assortmentFilter = await modules.assortments.filters.create({
+      assortmentId,
+      filterId,
+      tags,
+    } as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            assortmentFilter: {
+              ...assortmentFilter,
+              filter,
+              assortment,
+            },
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error adding filter to assortment: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/assortment/addAssortmentLinkHandler.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';
+import { AssortmentNotFoundError } from '../../../errors.js';
+
+export const AddAssortmentLinkSchema = {
+  parentAssortmentId: z.string().min(1).describe('ID of the parent assortment'),
+  childAssortmentId: z.string().min(1).describe('ID of the child assortment'),
+  tags: z.array(z.string().min(1)).default([]).describe('Tags for the link'),
+};
+
+export const AddAssortmentLinkZodSchema = z.object(AddAssortmentLinkSchema);
+
+export type AddAssortmentLinkParams = z.infer<typeof AddAssortmentLinkZodSchema>;
+
+export async function addAssortmentLinkHandler(context: Context, params: AddAssortmentLinkParams) {
+  const { parentAssortmentId, childAssortmentId, tags } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler addAssortmentLink', {
+      userId,
+      parentAssortmentId,
+      childAssortmentId,
+      tags,
+    });
+    const parent = await getNormalizedAssortmentDetails({ assortmentId: parentAssortmentId }, context);
+    if (!parent)
+      throw new AssortmentNotFoundError({
+        assortmentId: parentAssortmentId,
+      });
+    const child = await getNormalizedAssortmentDetails({ assortmentId: childAssortmentId }, context);
+    if (!child)
+      throw new AssortmentNotFoundError({
+        assortmentId: childAssortmentId,
+      });
+
+    const result = await modules.assortments.links.create({
+      parentAssortmentId,
+      childAssortmentId,
+      tags,
+    } as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ assortmentLink: { ...result, parent, child } }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error adding assortment link: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { FileNotFoundError, FileUploadExpiredError } from '../../../errors.js';
+
+export const AddAssortmentMediaUploadSchema = {
+  mediaName: z
+    .string()
+    .min(1)
+    .describe('Name of the media file (e.g. "image.png") use random name if not provided'),
+  assortmentId: z.string().min(1).describe('ID of the assortment to link media to'),
+  url: z.string().describe('Anonymously fetchable URL of the source media, can be a data URL too'),
+};
+
+export const AddAssortmentMediaUploadZodSchema = z.object(AddAssortmentMediaUploadSchema);
+
+export type AddAssortmentMediaUploadParams = z.infer<typeof AddAssortmentMediaUploadZodSchema>;
+
+export async function addAssortmentMediaUploadHandler(
+  context: Context,
+  params: AddAssortmentMediaUploadParams,
+) {
+  const { mediaName, assortmentId, url } = params;
+  const { modules, services, userId } = context;
+
+  try {
+    log('handler addAssortmentMediaUploadHandler', { mediaName, assortmentId, userId, url });
+    const {
+      _id: fileId,
+      putURL,
+      type,
+      size,
+    } = await services.files.createSignedURL({
+      directoryName: 'assortment-media',
+      fileName: mediaName,
+      meta: { assortmentId },
+    });
+
+    const sourceResponse = await fetch(url);
+    const uploadUrl = new URL(putURL, process.env.ROOT_URL || 'http://localhost:4010');
+    const uploadResponse = await fetch(uploadUrl, {
+      method: 'PUT',
+      body: sourceResponse.body,
+      duplex: 'half',
+    } as RequestInit);
+
+    if (!uploadResponse.ok) {
+      throw new Error(`Upload failed: ${uploadResponse.status} ${uploadResponse.statusText}`);
+    }
+
+    const file = await modules.files.findFile({ fileId });
+    if (!file) throw new FileNotFoundError({ fileId });
+
+    if (file.expires && new Date(file.expires).getTime() < Date.now()) {
+      throw new FileUploadExpiredError({ fileId });
+    }
+    const linked = await services.files.linkFile({ fileId, size, type });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            file: linked,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error uploading Assortment media: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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