@unchainedshop/api 3.1.15 → 4.0.0-rc.10

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

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentMediaNotFoundError } from '../../../errors.js';
+
+export const AssortmentMediaTextInputSchema = z.object({
+  locale: z
+    .string()
+    .min(2)
+    .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',
+    ),
+  title: z.string().optional().describe('Title in the given locale'),
+  subtitle: z.string().optional().describe('Subtitle in the given locale'),
+});
+
+export const UpdateAssortmentMediaTextsSchema = {
+  assortmentMediaId: z.string().min(1).describe('ID of the assortment media to update'),
+  texts: z.array(AssortmentMediaTextInputSchema).min(1).describe('Localized text values to update'),
+};
+
+export const UpdateAssortmentMediaTextsZodSchema = z.object(UpdateAssortmentMediaTextsSchema);
+
+export type UpdateAssortmentMediaTextsParams = z.infer<typeof UpdateAssortmentMediaTextsZodSchema>;
+
+export async function updateAssortmentMediaTextsHandler(
+  context: Context,
+  params: UpdateAssortmentMediaTextsParams,
+) {
+  const { assortmentMediaId, texts } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler updateAssortmentMediaTextsHandler', { userId, params });
+
+    const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
+      assortmentMediaId,
+    });
+
+    if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
+
+    const assortmentMediaTexts = await modules.assortments.media.texts.updateMediaTexts(
+      assortmentMediaId,
+      texts,
+    );
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            texts: assortmentMediaTexts,
+            assortmentId: assortmentMedia?.assortmentId,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating assortment media texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentNotFoundError } from '../../../errors.js';
+
+export const AssortmentAssortmentTextInputSchema = z.object({
+  locale: z
+    .string()
+    .min(2)
+    .describe(
+      `Locale ISO code for the language of the text (e.g., "en-US", "de-CH").
+If not provided, fallback to the shop's defaultLanguageIsoCode.
+If provided, it must be a valid language configured in the shop.`,
+    ),
+  slug: z
+    .string()
+    .optional()
+    .describe('Optional URL-safe identifier for the assortment (e.g., "summer-sale").'),
+  title: z.string().optional().describe('Optional title for the assortment in this locale.'),
+  subtitle: z.string().optional().describe('Optional subtitle providing extra context.'),
+  description: z.string().optional().describe('Optional long-form description of the assortment.'),
+});
+
+export const UpdateAssortmentTextsSchema = {
+  assortmentId: z.string().min(1).describe('ID of the assortment to update'),
+  texts: z.array(AssortmentAssortmentTextInputSchema).min(1).describe('Localized metadata to update'),
+};
+
+export const UpdateAssortmentTextsZodSchema = z.object(UpdateAssortmentTextsSchema);
+
+export type UpdateAssortmentTextsParams = z.infer<typeof UpdateAssortmentTextsZodSchema>;
+
+export async function updateAssortmentTextsHandler(
+  context: Context,
+  params: UpdateAssortmentTextsParams,
+) {
+  const { assortmentId, texts } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler updateAssortmentTextsHandler', { userId, params });
+
+    if (!(await modules.assortments.assortmentExists({ assortmentId })))
+      throw new AssortmentNotFoundError({ assortmentId });
+
+    const assortmentTexts = await modules.assortments.texts.updateTexts(assortmentId, texts as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts: assortmentTexts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating assortment texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/country/countriesCountHandler.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const CountriesCountSchema = {
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('If true, include inactive countries in the count. Defaults to false.'),
+  queryString: z
+    .string()
+    .optional()
+    .describe('Optional search string to filter countries by name or code'),
+};
+
+export const CountriesCountZodSchema = z.object(CountriesCountSchema);
+
+export type CountriesCountParams = z.infer<typeof CountriesCountZodSchema>;
+
+export async function countriesCountHandler(context: Context, params: CountriesCountParams) {
+  const { modules, userId } = context;
+
+  try {
+    log(`handler countriesCountHandler`, {
+      userId,
+      params,
+    });
+
+    const count = await modules.countries.count(params);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify(count),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error counting countries: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/country/countriesHandler.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { SortDirection } from '@unchainedshop/utils';
+import { log } from '@unchainedshop/logger';
+
+const sortDirectionKeys = Object.keys(SortDirection) as [
+  keyof typeof SortDirection,
+  ...(keyof typeof SortDirection)[],
+];
+
+export const ListCountriesSchema = {
+  limit: z
+    .number()
+    .int()
+    .min(1)
+    .max(100)
+    .default(50)
+    .describe('Maximum number of countries to return (pagination limit)'),
+  offset: z
+    .number()
+    .int()
+    .min(0)
+    .default(0)
+    .describe('Number of countries to skip before starting to collect the result set'),
+  includeInactive: z
+    .boolean()
+    .default(false)
+    .describe('Whether to include inactive (disabled) countries in the results'),
+  queryString: z
+    .string()
+    .min(1)
+    .optional()
+    .describe('Optional case-insensitive text filter to search country name or code'),
+  sort: z
+    .array(
+      z.object({
+        key: z.string().min(1).describe('Field name to sort by (e.g., "name", "isoCode")'),
+        value: z.enum(sortDirectionKeys).describe('Sorting direction, either "ASC" or "DESC"'),
+      }),
+    )
+    .optional()
+    .describe('List of fields and their corresponding sort directions'),
+};
+
+export const ListCountriesZodSchema = z.object(ListCountriesSchema);
+
+export type ListCountriesParams = z.infer<typeof ListCountriesZodSchema>;
+
+export async function countriesHandler(context: Context, params: ListCountriesParams) {
+  const { limit, offset, includeInactive, queryString, sort } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler countriesHandler`, {
+      userId,
+      params,
+    });
+    const countries = await modules.countries.findCountries({
+      limit,
+      offset,
+      includeInactive,
+      queryString,
+      sort: sort as any[],
+    });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ countries }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error retrieving countries: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/country/countryHandler.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { CountryNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
+
+export const CountrySchema = {
+  countryId: z.string().min(1).describe('ID of the country to retrieve'),
+};
+
+export const CountryZodSchema = z.object(CountrySchema);
+
+export type CountryParams = z.infer<typeof CountryZodSchema>;
+
+export async function countryHandler(context: Context, params: CountryParams) {
+  const { countryId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler countryHandler`, {
+      userId,
+      params,
+    });
+    const country = await modules.countries.findCountry({ countryId });
+
+    if (!country) throw new CountryNotFoundError({ countryId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ country }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error retrieving country: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/country/createCountryHandler.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const CreateCountrySchema = {
+  country: z.object({
+    isoCode: z
+      .string()
+      .min(2)
+      .max(2)
+      .toUpperCase()
+      .describe('2-letter ISO 3166-1 alpha-2 country code (e.g., "CH", "US")'),
+  }),
+};
+
+export const CreateCountryZodSchema = z.object(CreateCountrySchema);
+export type CreateCountryParams = z.infer<typeof CreateCountryZodSchema>;
+
+export async function createCountryHandler(context: Context, params: CreateCountryParams) {
+  const { country } = params;
+  const { modules, userId } = context;
+  try {
+    log(`handler createCountryHandler`, { userId, params });
+
+    const countryId = await modules.countries.create(country as any);
+
+    const newCountry = await modules.countries.findCountry({ countryId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ country: newCountry }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error creating country: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,46 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { CountriesCountSchema, countriesCountHandler } from './countriesCountHandler.js';
+import { ListCountriesSchema, countriesHandler } from './countriesHandler.js';
+import { CountrySchema, countryHandler } from './countryHandler.js';
+import { CreateCountrySchema, createCountryHandler } from './createCountryHandler.js';
+import { RemoveCountrySchema, removeCountryHandler } from './removeCountryHandler.js';
+import { UpdateCountrySchema, updateCountryHandler } from './updateCountryHandler.js';
+
+export const registerCountryTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'country_list',
+    'List countries with optional pagination, search, sorting, and inactive flag.',
+    ListCountriesSchema,
+    async (params) => countriesHandler(context, params),
+  );
+
+  server.tool('country_get', 'Retrieve a country by ID', CountrySchema, async (params) =>
+    countryHandler(context, params),
+  );
+
+  server.tool(
+    'country_create',
+    'Create a new country using its ISO 3166-1 alpha-2 code.',
+    CreateCountrySchema,
+    async (params) => createCountryHandler(context, params),
+  );
+
+  server.tool(
+    'country_update',
+    'Update details for a given country',
+    UpdateCountrySchema,
+    async (params) => updateCountryHandler(context, params),
+  );
+
+  server.tool('country_remove', 'Remove a country by its ID', RemoveCountrySchema, async (params) =>
+    removeCountryHandler(context, params),
+  );
+
+  server.tool(
+    'country_count',
+    'Return the number of countries, optionally filtered by search or inactive status.',
+    CountriesCountSchema,
+    async (params) => countriesCountHandler(context, params),
+  );
+};

package/src/mcp/tools/country/removeCountryHandler.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { CountryNotFoundError } from '../../../errors.js';
+
+export const RemoveCountrySchema = {
+  countryId: z.string().min(1).describe('ID of the country to remove'),
+};
+
+export const RemoveCountryZodSchema = z.object(RemoveCountrySchema);
+
+export type RemoveCountryParams = z.infer<typeof RemoveCountryZodSchema>;
+
+export async function removeCountryHandler(context: Context, params: RemoveCountryParams) {
+  const { countryId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler removeCountryHandler`, { userId, params });
+
+    if (!(await modules.countries.countryExists({ countryId })))
+      throw new CountryNotFoundError({ countryId });
+
+    await modules.countries.delete(countryId);
+
+    const removedCountry = await modules.countries.findCountry({ countryId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ country: removedCountry }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error removing country: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/country/updateCountryHandler.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { CountryNotFoundError } from '../../../errors.js';
+
+export const UpdateCountrySchema = {
+  countryId: z.string().min(1).describe('ID of the country to update'),
+  country: z.object({
+    isoCode: z
+      .string()
+      .min(2)
+      .max(2)
+      .toUpperCase()
+      .describe('2-letter ISO 3166-1 alpha-2 country code (e.g., "CH", "US")'),
+    isActive: z.boolean().optional().describe('Whether the country is active'),
+    defaultCurrencyCode: z
+      .string()
+      .min(3)
+      .max(3)
+      .toUpperCase()
+      .optional()
+      .describe('Default currency code (e.g., "USD", "CHF")'),
+  }),
+};
+
+export const UpdateCountryZodSchema = z.object(UpdateCountrySchema);
+export type UpdateCountryParams = z.infer<typeof UpdateCountryZodSchema>;
+
+export async function updateCountryHandler(context: Context, params: UpdateCountryParams) {
+  const { country, countryId } = params;
+  const { modules, userId } = context;
+  try {
+    log(`handler updateCountryHandler`, { userId, params });
+
+    if (!(await modules.countries.countryExists({ countryId })))
+      throw new CountryNotFoundError({ countryId });
+
+    await modules.countries.update(countryId, country as any);
+
+    const updatedCountry = await modules.countries.findCountry({ countryId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ country: updatedCountry }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating country: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/currency/createCurrencyHandler.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const CreateCurrencySchema = {
+  currency: z.object({
+    isoCode: z
+      .string()
+      .min(3)
+      .max(3)
+      .toUpperCase()
+      .describe('3-letter ISO 4217 currency code (e.g., "USD", "EUR", "CHF")'),
+    contractAddress: z
+      .string()
+      .regex(/^0x[a-fA-F0-9]{40}$/, 'Must be a valid 42-character blockchain address')
+      .optional()
+      .describe('Optional blockchain contract address for the currency'),
+    decimals: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .describe('Optional decimal precision used by the currency (e.g., 2 for USD, 18 for ETH)'),
+  }),
+};
+
+export const CreateCurrencyZodSchema = z.object(CreateCurrencySchema);
+export type CreateCurrencyParams = z.infer<typeof CreateCurrencyZodSchema>;
+
+export async function createCurrencyHandler(context: Context, params: CreateCurrencyParams) {
+  const { currency } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`Handler createCurrencyHandler`, { userId, params });
+
+    const currencyId = await modules.currencies.create(currency as any);
+
+    const newCurrency = await modules.currencies.findCurrency({ currencyId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ currency: newCurrency }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error creating currency: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/currency/currenciesCountHandler.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const CurrenciesCountSchema = {
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include inactive currencies in the count'),
+  queryString: z.string().optional().describe('Optional search string to filter currencies'),
+};
+
+export const CurrenciesCountZodSchema = z.object(CurrenciesCountSchema);
+
+export type CurrenciesCountParams = z.infer<typeof CurrenciesCountZodSchema>;
+
+export async function currenciesCountHandler(context: Context, params: CurrenciesCountParams) {
+  const { modules, userId } = context;
+  try {
+    log(`handler currenciesCountHandler`, {
+      userId,
+      params,
+    });
+
+    const count = await modules.currencies.count(params);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify(count),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error counting currencies: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/currency/currenciesHandler.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { SortDirection } from '@unchainedshop/utils';
+import { log } from '@unchainedshop/logger';
+
+const sortDirectionKeys = Object.keys(SortDirection) as [
+  keyof typeof SortDirection,
+  ...(keyof typeof SortDirection)[],
+];
+
+export const ListCurrenciesSchema = {
+  limit: z.number().int().min(1).max(100).default(50).describe('Maximum number of currencies to return'),
+  offset: z.number().int().min(0).default(0).describe('Number of currencies to skip (for pagination)'),
+  includeInactive: z
+    .boolean()
+    .default(false)
+    .describe('Whether to include inactive currencies in the results'),
+  queryString: z.string().min(1).optional().describe('Optional text search to filter currencies'),
+  sort: z
+    .array(
+      z.object({
+        key: z.string().min(1).describe('Field to sort by'),
+        value: z.enum(sortDirectionKeys).describe("Sort direction, either 'ASC' or 'DESC'"),
+      }),
+    )
+    .optional()
+    .describe('Sorting configuration'),
+};
+
+export const ListCurrenciesZodSchema = z.object(ListCurrenciesSchema);
+
+export type ListCurrenciesParams = z.infer<typeof ListCurrenciesZodSchema>;
+
+export async function currenciesHandler(context: Context, params: ListCurrenciesParams) {
+  const { limit, offset, includeInactive, queryString, sort } = params;
+
+  const { modules, userId } = context;
+
+  try {
+    log(`handler currenciesHandler`, {
+      userId,
+      params,
+    });
+    const currencies = await modules.currencies.findCurrencies({
+      limit,
+      offset,
+      includeInactive,
+      queryString,
+      sort: sort as any[],
+    });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({
+            currencies,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error retrieving currencies: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}