@unchainedshop/api 4.8.3 → 5.0.0-alpha.1

package/lib/mcp/tools/localization/schemas.d.ts

@@ -1,85 +1,119 @@
-import { z } from 'zod/v4-mini';
+import { z } from 'zod';
 import { SortDirection } from '@unchainedshop/utils';
+export type LocalizationType = 'COUNTRY' | 'CURRENCY' | 'LANGUAGE';
+export interface LocalizationModuleConfig {
+    module: any;
+    NotFoundError: any;
+    entityName: string;
+    idField: string;
+    existsMethod: any;
+    findMethod: any;
+    findMultipleMethod: any;
+}
+export interface LocalizationEntity {
+    isoCode: string;
+    contractAddress?: string;
+    decimals?: number;
+}
+export interface LocalizationUpdateEntity {
+    isoCode?: string;
+    contractAddress?: string;
+    decimals?: number;
+}
+export interface LocalizationListOptions {
+    limit?: number;
+    offset?: number;
+    includeInactive?: boolean;
+    queryString?: string;
+    sort?: {
+        key: string;
+        value: 'ASC' | 'DESC';
+    }[];
+}
+export interface LocalizationCountOptions {
+    includeInactive?: boolean;
+    queryString?: string;
+}
 export declare const sortDirectionKeys: [keyof typeof SortDirection, ...(keyof typeof SortDirection)[]];
-export declare const LocalizationTypeEnum: z.ZodMiniEnum<{
+export declare const LocalizationTypeEnum: z.ZodEnum<{
     COUNTRY: "COUNTRY";
     CURRENCY: "CURRENCY";
     LANGUAGE: "LANGUAGE";
 }>;
-export declare const LocalizationEntitySchema: z.ZodMiniObject<{
-    isoCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    isActive: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-    defaultCurrencyCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    contractAddress: z.ZodMiniOptional<z.ZodMiniString<string>>;
-    decimals: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+export declare const LocalizationEntitySchema: z.ZodObject<{
+    isoCode: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+    contractAddress: z.ZodOptional<z.ZodString>;
+    decimals: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const actionValidators: {
-    readonly CREATE: z.ZodMiniObject<{
-        localizationType: z.ZodMiniEnum<{
+    readonly CREATE: z.ZodObject<{
+        localizationType: z.ZodEnum<{
             COUNTRY: "COUNTRY";
             CURRENCY: "CURRENCY";
             LANGUAGE: "LANGUAGE";
         }>;
-        entity: z.ZodMiniObject<{
-            isActive: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-            defaultCurrencyCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            contractAddress: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            decimals: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
-            isoCode: z.ZodMiniString<string>;
+        entity: z.ZodObject<{
+            isActive: z.ZodOptional<z.ZodBoolean>;
+            defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+            contractAddress: z.ZodOptional<z.ZodString>;
+            decimals: z.ZodOptional<z.ZodNumber>;
+            isoCode: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>;
-    readonly UPDATE: z.ZodMiniObject<{
-        localizationType: z.ZodMiniEnum<{
+    readonly UPDATE: z.ZodObject<{
+        localizationType: z.ZodEnum<{
             COUNTRY: "COUNTRY";
             CURRENCY: "CURRENCY";
             LANGUAGE: "LANGUAGE";
         }>;
-        entityId: z.ZodMiniString<string>;
-        entity: z.ZodMiniObject<{
-            isoCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            isActive: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
-            defaultCurrencyCode: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            contractAddress: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            decimals: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
+        entityId: z.ZodString;
+        entity: z.ZodObject<{
+            isoCode: z.ZodOptional<z.ZodString>;
+            isActive: z.ZodOptional<z.ZodBoolean>;
+            defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+            contractAddress: z.ZodOptional<z.ZodString>;
+            decimals: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>;
     }, z.core.$strip>;
-    readonly REMOVE: z.ZodMiniObject<{
-        localizationType: z.ZodMiniEnum<{
+    readonly REMOVE: z.ZodObject<{
+        localizationType: z.ZodEnum<{
             COUNTRY: "COUNTRY";
             CURRENCY: "CURRENCY";
             LANGUAGE: "LANGUAGE";
         }>;
-        entityId: z.ZodMiniString<string>;
+        entityId: z.ZodString;
     }, z.core.$strip>;
-    readonly GET: z.ZodMiniObject<{
-        localizationType: z.ZodMiniEnum<{
+    readonly GET: z.ZodObject<{
+        localizationType: z.ZodEnum<{
             COUNTRY: "COUNTRY";
             CURRENCY: "CURRENCY";
             LANGUAGE: "LANGUAGE";
         }>;
-        entityId: z.ZodMiniString<string>;
+        entityId: z.ZodString;
     }, z.core.$strip>;
-    readonly LIST: z.ZodMiniObject<{
-        queryString: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        includeInactive: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
-        sort: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
-            key: z.ZodMiniString<string>;
-            value: z.ZodMiniEnum<{
+    readonly LIST: z.ZodObject<{
+        queryString: z.ZodOptional<z.ZodString>;
+        includeInactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodEnum<{
                 [x: string]: string;
             }>;
         }, z.core.$strip>>>;
-        limit: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
-        offset: z.ZodMiniOptional<z.ZodMiniNumberFormat>;
-        localizationType: z.ZodMiniEnum<{
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        localizationType: z.ZodEnum<{
             COUNTRY: "COUNTRY";
             CURRENCY: "CURRENCY";
             LANGUAGE: "LANGUAGE";
         }>;
     }, z.core.$strip>;
-    readonly COUNT: z.ZodMiniObject<{
-        queryString: z.ZodMiniOptional<z.ZodMiniString<string>>;
-        includeInactive: z.ZodMiniDefault<z.ZodMiniBoolean<boolean>>;
-        localizationType: z.ZodMiniEnum<{
+    readonly COUNT: z.ZodObject<{
+        queryString: z.ZodOptional<z.ZodString>;
+        includeInactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        localizationType: z.ZodEnum<{
             COUNTRY: "COUNTRY";
             CURRENCY: "CURRENCY";
             LANGUAGE: "LANGUAGE";
@@ -87,9 +121,72 @@ export declare const actionValidators: {
     }, z.core.$strip>;
 };
 export declare const LocalizationManagementSchema: {
-    action: z.core.$ZodType<string>;
-} & Record<string, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-export type { ManagementParams as LocalizationManagementParams } from '../../utils/sharedSchemas.ts';
+    queryString: z.ZodOptional<z.ZodString>;
+    includeInactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+    }, z.core.$strip>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodEnum<{
+        GET: "GET";
+        CREATE: "CREATE";
+        UPDATE: "UPDATE";
+        REMOVE: "REMOVE";
+        LIST: "LIST";
+        COUNT: "COUNT";
+    }>;
+    localizationType: z.ZodEnum<{
+        COUNTRY: "COUNTRY";
+        CURRENCY: "CURRENCY";
+        LANGUAGE: "LANGUAGE";
+    }>;
+    entity: z.ZodOptional<z.ZodObject<{
+        isoCode: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+        contractAddress: z.ZodOptional<z.ZodString>;
+        decimals: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    entityId: z.ZodOptional<z.ZodString>;
+};
+export declare const LocalizationManagementZodSchema: z.ZodObject<{
+    queryString: z.ZodOptional<z.ZodString>;
+    includeInactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+    }, z.core.$strip>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    action: z.ZodEnum<{
+        GET: "GET";
+        CREATE: "CREATE";
+        UPDATE: "UPDATE";
+        REMOVE: "REMOVE";
+        LIST: "LIST";
+        COUNT: "COUNT";
+    }>;
+    localizationType: z.ZodEnum<{
+        COUNTRY: "COUNTRY";
+        CURRENCY: "CURRENCY";
+        LANGUAGE: "LANGUAGE";
+    }>;
+    entity: z.ZodOptional<z.ZodObject<{
+        isoCode: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodOptional<z.ZodBoolean>;
+        defaultCurrencyCode: z.ZodOptional<z.ZodString>;
+        contractAddress: z.ZodOptional<z.ZodString>;
+        decimals: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    entityId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LocalizationManagementParams = z.infer<typeof LocalizationManagementZodSchema>;
 export type ActionName = keyof typeof actionValidators;
 export type Params<T extends ActionName> = z.infer<(typeof actionValidators)[T]>;
 export type Handler<T extends ActionName> = (localizationModule: any, params: Params<T>) => Promise<unknown>;

package/lib/mcp/tools/localization/schemas.js

@@ -1,68 +1,83 @@
-import { z } from 'zod/v4-mini';
+import { z } from 'zod';
 import { SortDirection } from '@unchainedshop/utils';
-import { PaginationSchema, SortingSchema, SearchSchema, createManagementSchemaFromValidators, } from "../../utils/sharedSchemas.js";
+import { PaginationSchema, SortingSchema, SearchSchema } from "../../utils/sharedSchemas.js";
 export const sortDirectionKeys = Object.keys(SortDirection);
 export const LocalizationTypeEnum = z
     .enum(['COUNTRY', 'CURRENCY', 'LANGUAGE'])
-    .check(z.describe('Type of localization entity - COUNTRY for geographic regions (US, DE, CH), CURRENCY for monetary units (USD, EUR, CHF), LANGUAGE for locale support (en, de, fr)'));
+    .describe('Type of localization entity - COUNTRY for geographic regions (US, DE, CH), CURRENCY for monetary units (USD, EUR, CHF), LANGUAGE for locale support (en, de, fr)');
 export const LocalizationEntitySchema = z.object({
     isoCode: z
-        .optional(z.string().check(z.minLength(1)))
-        .check(z.describe('ISO identifier: Countries need 2-letter codes (US, DE), Currencies need 3-letter codes (USD, EUR), Languages accept 2-10 characters (en, de-CH). isoCode is required for both CREATE and UPDATE operations')),
+        .string()
+        .min(1)
+        .optional()
+        .describe('ISO identifier: Countries need 2-letter codes (US, DE), Currencies need 3-letter codes (USD, EUR), Languages accept 2-10 characters (en, de-CH). isoCode is required for both CREATE and UPDATE operations'),
     isActive: z
-        .optional(z.boolean())
-        .check(z.describe('Active status for the entity - used for all localization types (COUNTRY, CURRENCY, LANGUAGE)')),
+        .boolean()
+        .optional()
+        .describe('Active status for the entity - used for all localization types (COUNTRY, CURRENCY, LANGUAGE)'),
     defaultCurrencyCode: z
-        .optional(z.string())
-        .check(z.describe('Default currency code for the country - only used when localizationType is COUNTRY, ignored otherwise')),
+        .string()
+        .optional()
+        .describe('Default currency code for the country - only used when localizationType is COUNTRY, ignored otherwise'),
     contractAddress: z
-        .optional(z
         .string()
-        .check(z.regex(/^0x[a-fA-F0-9]{40}$/, 'Must be a valid 42-character blockchain address starting with 0x')))
-        .check(z.describe('Blockchain contract address for tokenized currencies - only used when localizationType is CURRENCY, ignored otherwise')),
+        .regex(/^0x[a-fA-F0-9]{40}$/, 'Must be a valid 42-character blockchain address starting with 0x')
+        .optional()
+        .describe('Blockchain contract address for tokenized currencies - only used when localizationType is CURRENCY, ignored otherwise'),
     decimals: z
-        .optional(z.int().check(z.nonnegative()))
-        .check(z.describe('Decimal precision for currency calculations - only used when localizationType is CURRENCY (2 for traditional currencies like USD, 18 for crypto tokens), ignored otherwise')),
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe('Decimal precision for currency calculations - only used when localizationType is CURRENCY (2 for traditional currencies like USD, 18 for crypto tokens), ignored otherwise'),
 });
 export const actionValidators = {
     CREATE: z.object({
-        localizationType: LocalizationTypeEnum.check(z.describe('Type of localization system to operate on')),
-        entity: z
-            .extend(LocalizationEntitySchema, {
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+        entity: LocalizationEntitySchema.extend({
             isoCode: z
                 .string()
-                .check(z.minLength(1), z.describe('ISO identifier: Countries need 2-letter codes (US, DE), Currencies need 3-letter codes (USD, EUR), Languages accept 2-10 characters (en, de-CH)')),
-        })
-            .check(z.describe('Entity configuration data (required for CREATE)')),
+                .min(1)
+                .describe('ISO identifier: Countries need 2-letter codes (US, DE), Currencies need 3-letter codes (USD, EUR), Languages accept 2-10 characters (en, de-CH)'),
+        }).describe('Entity configuration data (required for CREATE)'),
     }),
     UPDATE: z.object({
-        localizationType: LocalizationTypeEnum.check(z.describe('Type of localization system to operate on, wj')),
-        entityId: z
-            .string()
-            .check(z.minLength(1), z.describe('Database ID of the specific entity instance')),
-        entity: LocalizationEntitySchema.check(z.describe('Entity data to update')),
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on, wj'),
+        entityId: z.string().min(1).describe('Database ID of the specific entity instance'),
+        entity: LocalizationEntitySchema.describe('Entity data to update'),
     }),
     REMOVE: z.object({
-        localizationType: LocalizationTypeEnum.check(z.describe('Type of localization system to operate on')),
-        entityId: z
-            .string()
-            .check(z.minLength(1), z.describe('Database ID of the specific entity instance')),
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+        entityId: z.string().min(1).describe('Database ID of the specific entity instance'),
     }),
     GET: z.object({
-        localizationType: LocalizationTypeEnum.check(z.describe('Type of localization system to operate on')),
-        entityId: z
-            .string()
-            .check(z.minLength(1), z.describe('Database ID of the specific entity instance')),
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+        entityId: z.string().min(1).describe('Database ID of the specific entity instance'),
     }),
     LIST: z.object({
-        localizationType: LocalizationTypeEnum.check(z.describe('Type of localization system to operate on')),
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
         ...PaginationSchema,
         ...SortingSchema,
         ...SearchSchema,
     }),
     COUNT: z.object({
-        localizationType: LocalizationTypeEnum.check(z.describe('Type of localization system to operate on')),
+        localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
         ...SearchSchema,
     }),
 };
-export const LocalizationManagementSchema = createManagementSchemaFromValidators(actionValidators);
+export const LocalizationManagementSchema = {
+    action: z
+        .enum(['CREATE', 'UPDATE', 'REMOVE', 'GET', 'LIST', 'COUNT'])
+        .describe('Localization action: CREATE (new entity), UPDATE (modify existing), REMOVE (soft delete), GET (retrieve single), LIST (find multiple with pagination), COUNT (get totals for analytics)'),
+    localizationType: LocalizationTypeEnum.describe('Type of localization system to operate on'),
+    entity: LocalizationEntitySchema.optional().describe('Entity configuration data (required for CREATE, optional for UPDATE)'),
+    entityId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Database ID of the specific entity instance (required for UPDATE, REMOVE, GET actions)'),
+    ...PaginationSchema,
+    ...SortingSchema,
+    ...SearchSchema,
+};
+export const LocalizationManagementZodSchema = z.object(LocalizationManagementSchema);

package/lib/mcp/tools/order/handlers/getTopCustomers.d.ts

@@ -22,6 +22,8 @@ export default function getTopCustomers(context: Context, params: Params<'TOP_CU
             services: any;
             pushSubscriptions: import("@unchainedshop/core-users").PushSubscriptionObject[];
             username?: string | undefined;
+            tokenVersion?: number | undefined;
+            oidcLogoutAt?: Date | undefined;
             _id: string;
         } | null;
         currencyCode: string | null;

package/lib/mcp/tools/order/orderManagement.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '../../../context.ts';
-import { OrderManagementSchema, type OrderManagementParams } from './schemas.ts';
-export { OrderManagementSchema };
+import { OrderManagementSchema, OrderManagementZodSchema, type OrderManagementParams } from './schemas.ts';
+export { OrderManagementSchema, OrderManagementZodSchema };
 export type { OrderManagementParams };
 export declare function orderManagement(context: Context, params: OrderManagementParams): Promise<{
     content: {

package/lib/mcp/tools/order/orderManagement.js

@@ -1,8 +1,8 @@
 import { log } from '@unchainedshop/logger';
-import { actionValidators, OrderManagementSchema, } from "./schemas.js";
+import { actionValidators, OrderManagementSchema, OrderManagementZodSchema, } from "./schemas.js";
 import actionHandlers from "./handlers/index.js";
 import { createMcpResponse, createMcpErrorResponse } from "../../utils/sharedSchemas.js";
-export { OrderManagementSchema };
+export { OrderManagementSchema, OrderManagementZodSchema };
 export async function orderManagement(context, params) {
     const { action, ...actionParams } = params;
     log('MCP handler orderManagement ', { userId: context.userId, params });