oneentry 1.0.136 → 1.0.138

package/dist/base/syncModules.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// Using WeakMap to store unique instance IDs for each object instance
+const instanceIds = new WeakMap();
+// Counter to ensure even more uniqueness
+let instanceCounter = 0;
 /**
  * Abstract class representing synchronization modules.
  */
@@ -17,6 +21,15 @@ class SyncModules {
         this._sortAttributes = (data) => Object.fromEntries(Object.entries(data).sort(([, a], [, b]) => a.position - b.position));
         this.state = state;
         this._url = state.url;
+        // Generate and store a unique instance ID using WeakMap
+        if (!instanceIds.has(this)) {
+            const timestampPart = Date.now().toString(36);
+            const randomPart = Math.random().toString(36).substring(2, 15) +
+                Math.random().toString(36).substring(2, 15);
+            const counterPart = (++instanceCounter).toString(36);
+            const instanceId = `${timestampPart}${randomPart}${counterPart}`;
+            instanceIds.set(this, instanceId);
+        }
     }
     /**
      * Constructs the full URL path by appending the given path to the base URL.
@@ -136,44 +149,29 @@ class SyncModules {
         return result;
     }
     /**
-     * Generates intervals for a specific date based on a schedule.
-     * @param {Date} date - The date for which to generate intervals.
-     * @param {object} schedule - The schedule defining the intervals.
-     * @param {boolean} schedule.inEveryWeek  - The number of weeks between intervals.
-     * @param {any[]} schedule.times - The times for each interval.
-     * @param {boolean} schedule.inEveryMonth - The month intervals for each interval.
-     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
+     * Common logic for processing schedule dates (weekly, monthly, or both).
+     * @param {Date} date - The date for which to process intervals.
+     * @param {object} config - Configuration for schedule repetition.
+     * @param {boolean} config.inEveryWeek - Whether to repeat weekly.
+     * @param {boolean} config.inEveryMonth - Whether to repeat monthly.
+     * @param {Function} processDate - Callback function to process each date.
      */
-    _generateIntervalsForDate(date, schedule, utcIntervals) {
+    _processScheduleDates(date, config, processDate) {
         // Handle weekly schedules
-        if (schedule.inEveryWeek && !schedule.inEveryMonth) {
+        if (config.inEveryWeek && !config.inEveryMonth) {
             let currentDate = new Date(date);
             // Calculate the last day of the current month
             const endOfMonth = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0);
             while (currentDate <= endOfMonth) {
-                schedule.times.forEach((timeRange) => {
-                    const [startTime, endTime] = timeRange;
-                    const intervalStart = new Date(currentDate);
-                    intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
-                    const intervalEnd = new Date(currentDate);
-                    intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
-                    // Add JSON string to Set for uniqueness
-                    utcIntervals.add([
-                        intervalStart.toISOString(),
-                        intervalEnd.toISOString(),
-                    ]);
-                });
+                processDate(currentDate);
                 // Move to the next week
                 currentDate = this._addDays(currentDate, 7);
             }
         }
         // Handle monthly schedules
-        if (schedule.inEveryMonth && !schedule.inEveryWeek) {
-            // Начальная дата
+        if (config.inEveryMonth && !config.inEveryWeek) {
             const startDate = new Date(date);
-            // Определяем день месяца начальной даты
             const targetDayOfMonth = startDate.getUTCDate();
-            // Количество месяцев, на которые нужно повторить
             const numberOfMonths = 12;
             for (let i = 0; i < numberOfMonths; i++) {
                 const currentDate = new Date(startDate);
@@ -184,26 +182,13 @@ class SyncModules {
                 if (currentDate.getUTCMonth() !== (startDate.getUTCMonth() + i) % 12) {
                     continue; // Skip this month if exceeded
                 }
-                schedule.times.forEach((timeRange) => {
-                    const [startTime, endTime] = timeRange;
-                    const intervalStart = new Date(currentDate);
-                    intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
-                    const intervalEnd = new Date(currentDate);
-                    intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
-                    utcIntervals.add([
-                        intervalStart.toISOString(),
-                        intervalEnd.toISOString(),
-                    ]);
-                });
+                processDate(currentDate);
             }
         }
         // Handle both weekly and monthly schedules
-        if (schedule.inEveryMonth && schedule.inEveryWeek) {
-            // Initial date
+        if (config.inEveryMonth && config.inEveryWeek) {
             const startDate = new Date(date);
-            // Determine the day of the week
             const targetDayOfWeek = startDate.getUTCDay();
-            // Number of months to repeat
             const numberOfMonths = 12;
             for (let i = 0; i < numberOfMonths; i++) {
                 const currentDate = new Date(startDate);
@@ -216,30 +201,50 @@ class SyncModules {
                 // Iterate over all target days of the week in the current month
                 while (currentDate.getUTCMonth() ===
                     (startDate.getUTCMonth() + i) % 12) {
-                    schedule.times.forEach((timeRange) => {
-                        const [startTime, endTime] = timeRange;
-                        const intervalStart = new Date(currentDate);
-                        intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
-                        const intervalEnd = new Date(currentDate);
-                        intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
-                        utcIntervals.add([
-                            intervalStart.toISOString(),
-                            intervalEnd.toISOString(),
-                        ]);
-                    });
+                    processDate(currentDate);
                     // Move to the next week (same day of the week)
                     currentDate.setUTCDate(currentDate.getUTCDate() + 7);
                 }
             }
         }
     }
+    /**
+     * Generates intervals for a specific date based on a schedule.
+     * @param {Date} date - The date for which to generate intervals.
+     * @param {object} schedule - The schedule defining the intervals.
+     * @param {boolean} schedule.inEveryWeek  - The number of weeks between intervals.
+     * @param {any[]} schedule.times - The times for each interval.
+     * @param {boolean} schedule.inEveryMonth - The month intervals for each interval.
+     * @param {Set<Array<string>>} utcIntervals - A set to store unique intervals.
+     */
+    _generateIntervalsForDate(date, schedule, utcIntervals) {
+        this._processScheduleDates(date, schedule, (currentDate) => {
+            schedule.times.forEach((timeRange) => {
+                const [startTime, endTime] = timeRange;
+                const intervalStart = new Date(currentDate);
+                intervalStart.setUTCHours(startTime.hours, startTime.minutes, 0, 0);
+                const intervalEnd = new Date(currentDate);
+                intervalEnd.setUTCHours(endTime.hours, endTime.minutes, 0, 0);
+                utcIntervals.add([
+                    intervalStart.toISOString(),
+                    intervalEnd.toISOString(),
+                ]);
+            });
+        });
+    }
     /**
      * Adds time intervals to schedules.
      * @param {any[]} schedules - The schedules to process.
      * @returns {any} Schedules with added time intervals.
      */
     _addTimeIntervalsToSchedules(schedules) {
-        schedules.forEach((scheduleGroup) => {
+        schedules === null || schedules === void 0 ? void 0 : schedules.forEach((scheduleGroup) => {
+            // Skip if scheduleGroup.values is not an array
+            if (!scheduleGroup ||
+                !scheduleGroup.values ||
+                !Array.isArray(scheduleGroup.values)) {
+                return;
+            }
             scheduleGroup.values.forEach((schedule) => {
                 const utcIntervals = new Set();
                 const startDate = new Date(schedule.dates[0]);
@@ -294,48 +299,7 @@ class SyncModules {
                 }
             });
         };
-        // Handle weekly schedules
-        if (interval.inEveryWeek && !interval.inEveryMonth) {
-            let currentDate = new Date(date);
-            const endOfMonth = new Date(currentDate.getFullYear(), currentDate.getMonth() + 1, 0);
-            while (currentDate <= endOfMonth) {
-                generateTimeSlotsForDate(currentDate);
-                currentDate = this._addDays(currentDate, 7);
-            }
-        }
-        // Handle monthly schedules
-        if (interval.inEveryMonth && !interval.inEveryWeek) {
-            const startDate = new Date(date);
-            const targetDayOfMonth = startDate.getUTCDate();
-            const numberOfMonths = 12;
-            for (let i = 0; i < numberOfMonths; i++) {
-                const currentDate = new Date(startDate);
-                currentDate.setUTCMonth(currentDate.getUTCMonth() + i);
-                currentDate.setUTCDate(targetDayOfMonth);
-                if (currentDate.getUTCMonth() !== (startDate.getUTCMonth() + i) % 12) {
-                    continue;
-                }
-                generateTimeSlotsForDate(currentDate);
-            }
-        }
-        // Handle both weekly and monthly schedules
-        if (interval.inEveryMonth && interval.inEveryWeek) {
-            const startDate = new Date(date);
-            const targetDayOfWeek = startDate.getUTCDay();
-            const numberOfMonths = 12;
-            for (let i = 0; i < numberOfMonths; i++) {
-                const currentDate = new Date(startDate);
-                currentDate.setUTCMonth(currentDate.getUTCMonth() + i);
-                currentDate.setUTCDate(1);
-                const daysUntilTargetDay = (targetDayOfWeek - currentDate.getUTCDay() + 7) % 7;
-                currentDate.setUTCDate(currentDate.getUTCDate() + daysUntilTargetDay);
-                while (currentDate.getUTCMonth() ===
-                    (startDate.getUTCMonth() + i) % 12) {
-                    generateTimeSlotsForDate(currentDate);
-                    currentDate.setUTCDate(currentDate.getUTCDate() + 7);
-                }
-            }
-        }
+        this._processScheduleDates(date, interval, generateTimeSlotsForDate);
     }
     /**
      * Adds time intervals to form schedules (different structure).
@@ -368,6 +332,16 @@ class SyncModules {
         });
         return intervals;
     }
+    /**
+     * Transforms additionalFields from array to object keyed by marker.
+     * Skipped when rawData is enabled in config.
+     * @param {any} attr - The attribute object that may contain additionalFields.
+     */
+    _normalizeAdditionalFields(attr) {
+        if (!this.state.rawData && Array.isArray(attr.additionalFields)) {
+            attr.additionalFields = Object.fromEntries(attr.additionalFields.map((field) => [field.marker, field]));
+        }
+    }
     /**
      * Normalizes attributes within the data.
      * @param {any} data - The data to normalize.
@@ -379,6 +353,7 @@ class SyncModules {
         if ('attributeValues' in data) {
             for (const attr in data.attributeValues) {
                 const d = data.attributeValues[attr];
+                this._normalizeAdditionalFields(d);
                 // normalize numbers
                 if (d.type === 'integer' || d.type === 'float') {
                     const numValue = Number(d.value);
@@ -403,6 +378,7 @@ class SyncModules {
         if ('attributes' in data) {
             const d = data.attributes;
             for (const attr in d) {
+                this._normalizeAdditionalFields(d[attr]);
                 // Normalize numbers
                 // if (d[attr].type === 'integer' || d[attr].type === 'float') {
                 //   const numValue = Number(d[attr].value);
@@ -422,6 +398,7 @@ class SyncModules {
         }
         //  For single attribute - for attribute sets
         if ('type' in data) {
+            this._normalizeAdditionalFields(data);
             // Normalize numbers
             if (data.type === 'integer' || data.type === 'float') {
                 const numValue = Number(data.value);
@@ -478,12 +455,29 @@ class SyncModules {
         }
         // Access navigator through globalThis.window object to avoid direct reference
         const win = globalThis.window;
-        const nav = (win === null || win === void 0 ? void 0 : win.navigator) || {};
+        // Get the instance ID from the WeakMap
+        const instanceId = instanceIds.get(this) ||
+            Date.now().toString(36) +
+                Math.random().toString(36).substring(2, 15) +
+                Math.random().toString(36).substring(2, 15) +
+                (++instanceCounter).toString(36);
+        // Node.js environment - unique per-instance fingerprint (no shared process ID)
+        if (!win) {
+            return JSON.stringify({
+                fingerprint: `UQ_${instanceId}`,
+                deviceInfo: {
+                    os: 'Node.js',
+                    browser: `Node.js/${instanceId.substring(0, 10)}`,
+                    location: 'en-US',
+                },
+            });
+        }
+        const nav = win.navigator || {};
         const platform = nav.platform || 'Win32';
         const userAgent = nav.userAgent || 'Node.js/22';
         const language = nav.language || 'en-US';
         // Get screen information if available
-        const screen = (win === null || win === void 0 ? void 0 : win.screen) || {};
+        const screen = win.screen || {};
         const screenWidth = screen.width || 0;
         const screenHeight = screen.height || 0;
         const colorDepth = screen.colorDepth || 0;
@@ -500,7 +494,7 @@ class SyncModules {
         let isPrivateBrowsing = false;
         try {
             // Simple localStorage test to detect private browsing
-            if (win === null || win === void 0 ? void 0 : win.localStorage) {
+            if (win.localStorage) {
                 const testKey = 'test_private_browsing';
                 win.localStorage.setItem(testKey, '1');
                 win.localStorage.removeItem(testKey);
@@ -514,7 +508,7 @@ class SyncModules {
             isPrivateBrowsing = true; // Error during localStorage access indicates private browsing
         }
         // Create a stable fingerprint string using stable device/browser characteristics
-        const fingerprintString = `${platform}|${userAgent}|${language}|${screenWidth}|${screenHeight}|${colorDepth}|${timezone}|${isPrivateBrowsing ? 'private' : 'normal'}`;
+        const fingerprintString = `${platform}|${userAgent}|${language}|${screenWidth}|${screenHeight}|${colorDepth}|${timezone}|${isPrivateBrowsing ? 'private' : 'normal'}|${instanceId}`;
         // Simple but stable hash function
         let hash = 0;
         for (let i = 0; i < fingerprintString.length; i++) {
@@ -523,7 +517,7 @@ class SyncModules {
             hash = hash & hash; // Convert to 32-bit integer
         }
         const deviceMetadata = {
-            fingerprint: `UQ_${Math.abs(hash).toString(36)}`,
+            fingerprint: `UQ_${Math.abs(hash).toString(36)}_${instanceId.substring(0, 12)}`,
             deviceInfo: {
                 os: platform.replace(/ /g, '_'),
                 browser: userAgent.replace(/ /g, '_'),

package/dist/base/utils.d.ts

@@ -1,13 +1,19 @@
+/**
+ * @typedef {string} Types - Type of block.
+ */
 type Types = 'product' | 'error_page' | 'catalog_page' | 'product_preview' | 'similar_products_block' | 'product_block' | 'form' | 'common_page' | 'common_block' | 'order' | 'service' | 'none';
 /**
- * @param {string} [token] - If your project is protected by a token, specify this token in this parameter.
- * @param {string} [langCode] - specify the default language to avoid specifying it in every request.
- * @param {boolean} [traficLimit] - Some methods use multiple queries to make it easier to work with the API. Set this parameter to "false" to save traffic and decide for yourself what data you need.
- * @param {boolean} [auth] - An object with authorization settings.
- * @param {boolean} [auth.customAuth] - Set this flag to true if you want to configure the authorization process yourself. Set the flag to false, or do not pass it at all to have automatic authorization and token renewal.
- * @param {boolean} [auth.refreshToken] - Transfer the refresh token here, for example from the local storage, to resume the user's session. Otherwise, the user will need to log in every time a new session is created.
- * @param {boolean} [auth.providerMarker] - The marker of the provider, for example, email, google, facebook, etc. Default 'email';
- * @param {boolean} [auth.saveFunction] - If you want to store the token between sessions, for example in local storage, create a custom function that takes refreshToken as a parameter and executes the necessary instructions. This function will be called every time the tokens are updated.
+ * @property {string} [token] - If your project is protected by a token, specify this token in this parameter.
+ * @property {string} [langCode] - specify the default language to avoid specifying it in every request.
+ * @property {boolean} [traficLimit] - Some methods use multiple queries to make it easier to work with the API. Set this parameter to "false" to save traffic and decide for yourself what data you need.
+ * @property {boolean} [rawData] - Set to true to receive raw API responses without any transformation.
+ * @property {object} [validation] - Validation settings for API responses.
+ * @property {boolean} [auth] - An object with authorization settings.
+ * @property {boolean} [auth.customAuth] - Set this flag to true if you want to configure the authorization process yourself. Set the flag to false, or do not pass it at all to have automatic authorization and token renewal.
+ * @property {boolean} [auth.refreshToken] - Transfer the refresh token here, for example from the local storage, to resume the user's session. Otherwise, the user will need to log in every time a new session is created.
+ * @property {boolean} [auth.providerMarker] - The marker of the provider, for example, email, google, facebook, etc. Default 'email';
+ * @property {boolean} [auth.saveFunction] - If you want to store the token between sessions, for example in local storage, create a custom function that takes refreshToken as a parameter and executes the necessary instructions. This function will be called every time the tokens are updated.
+ * @property {object} [errors] - Error handling settings.
  * @example
  * ```ts
  * const saveToken = (token) => {
@@ -27,8 +33,11 @@ type Types = 'product' | 'error_page' | 'catalog_page' | 'product_preview' | 'si
  *     errors: {
  *         isShell: true,
  *         customErrors: {
+ *             '400': badRequestFunction,
  *             '404': notFoundFunction,
- *             '400': errorFunction
+ *             '429': rateLimitFunction,
+ *             '500': serverErrorFunction,
+ *             '503': serviceUnavailableFunction
  *         }
  *     }
  * }
@@ -38,6 +47,12 @@ interface IConfig {
     token?: string;
     langCode?: string;
     traficLimit?: boolean;
+    rawData?: boolean;
+    validation?: {
+        enabled?: boolean;
+        strictMode?: boolean;
+        logErrors?: boolean;
+    };
     auth?: {
         customAuth?: boolean;
         refreshToken?: string;
@@ -51,7 +66,11 @@ interface IConfig {
             401?: (data?: IError) => any;
             403?: (data?: IError) => any;
             404?: (data?: IError) => any;
+            429?: (data?: IError) => any;
             500?: (data?: IError) => any;
+            502?: (data?: IError) => any;
+            503?: (data?: IError) => any;
+            504?: (data?: IError) => any;
         };
     };
 }
@@ -136,6 +155,33 @@ interface IError {
     timestamp: string;
     [key: string]: any;
 }
+/**
+ * @interface IHttpHeaders
+ * @property {string} [Content-Type] - Content type header
+ * @property {string} [x-app-token] - App token header
+ * @property {string} [x-device-metadata] - Device metadata header
+ * @property {string} [Authorization] - Authorization header
+ * @description Interface for HTTP headers
+ */
+interface IHttpHeaders {
+    'Content-Type'?: string;
+    'x-app-token'?: string;
+    'x-device-metadata'?: string;
+    Authorization?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * @interface IHttpOptions
+ * @property {string} method - HTTP method
+ * @property {IHttpHeaders} headers - HTTP headers
+ * @property {string | FormData | Blob} [body] - Request body
+ * @description Interface for HTTP request options
+ */
+interface IHttpOptions {
+    method: string;
+    headers: IHttpHeaders;
+    body?: string | FormData | Blob;
+}
 /**
  * AttributeType
  */
@@ -148,4 +194,4 @@ type LangType = string | Array<string>;
  * LocalizeType
  */
 type LocalizeType = ILocalizeInfos | ILocalizeInfo;
-export type { AttributeType, IAttributes, IAttributeValues, IConfig, IError, ILocalizeInfo, ILocalizeInfos, LangType, LocalizeType, Types, };
+export type { AttributeType, IAttributes, IAttributeValues, IConfig, IError, IHttpHeaders, IHttpOptions, ILocalizeInfo, ILocalizeInfos, LangType, LocalizeType, Types, };

package/dist/base/validation.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+/**
+ * Common validation schemas for API responses
+ * @description Base schemas that can be reused across different modules
+ */
+/**
+ * Error response schema
+ */
+export declare const ErrorSchema: z.ZodObject<{
+    statusCode: z.ZodNumber;
+    message: z.ZodString;
+    localizeMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Localize info schema
+ */
+export declare const LocalizeInfoSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+    menuTitle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Attribute schema
+ */
+export declare const AttributeSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNumber>;
+    marker: z.ZodString;
+    type: z.ZodString;
+    isVisible: z.ZodOptional<z.ZodBoolean>;
+    isRequired: z.ZodOptional<z.ZodBoolean>;
+    position: z.ZodOptional<z.ZodNumber>;
+    localizeInfos: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        menuTitle: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    value: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+/**
+ * User entity schema
+ */
+export declare const UserEntitySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    identifier: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    phoneMask: z.ZodOptional<z.ZodString>;
+    phoneCode: z.ZodOptional<z.ZodString>;
+    phoneNumber: z.ZodOptional<z.ZodString>;
+    statusMarker: z.ZodOptional<z.ZodString>;
+    formData: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodAny>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+    total: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    authProviderIdentifier: z.ZodOptional<z.ZodString>;
+    formIdentifier: z.ZodOptional<z.ZodString>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    moduleFormConfigs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+}, z.core.$strip>;
+/**
+ * Auth entity schema
+ * API returns only accessToken and refreshToken
+ * userIdentifier and authProviderIdentifier are optional legacy fields
+ */
+export declare const AuthEntitySchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    userIdentifier: z.ZodOptional<z.ZodString>;
+    authProviderIdentifier: z.ZodOptional<z.ZodString>;
+    user: z.ZodOptional<z.ZodObject<{
+        id: z.ZodNumber;
+        identifier: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        phoneMask: z.ZodOptional<z.ZodString>;
+        phoneCode: z.ZodOptional<z.ZodString>;
+        phoneNumber: z.ZodOptional<z.ZodString>;
+        statusMarker: z.ZodOptional<z.ZodString>;
+        formData: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodAny>, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+        total: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        authProviderIdentifier: z.ZodOptional<z.ZodString>;
+        formIdentifier: z.ZodOptional<z.ZodString>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        moduleFormConfigs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Paginated response schema factory
+ * @param {T} itemSchema - The schema for each item in the paginated response
+ * @returns {any} Paginated response schema
+ */
+export declare function createPaginatedSchema<T extends z.ZodTypeAny>(itemSchema: T): any;
+/**
+ * Validation helper function
+ * @param {z.ZodSchema<T>} schema - Zod schema to validate against
+ * @param {unknown} data - Data to validate
+ * @param {object} options - Validation options
+ * @param {boolean} options.strict - Whether to use strict mode
+ * @param {boolean} options.logErrors - Whether to log errors
+ * @returns {object} Validated data or error
+ */
+export declare function validateResponse<T>(schema: z.ZodSchema<T>, data: unknown, options?: {
+    strict?: boolean;
+    logErrors?: boolean;
+}): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+/**
+ * Safe validation helper - returns data even if validation fails
+ * Used when strict mode is disabled
+ * @param {z.ZodSchema<T>} schema - Zod schema to validate against
+ * @param {unknown} data - Data to validate
+ * @param {boolean} logErrors - Whether to log errors
+ * @returns {T} Validated data or original data if validation fails in non-strict mode
+ */
+export declare function validateResponseSafe<T>(schema: z.ZodSchema<T>, data: unknown, logErrors?: boolean): T;

package/dist/base/validation.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthEntitySchema = exports.UserEntitySchema = exports.AttributeSchema = exports.LocalizeInfoSchema = exports.ErrorSchema = void 0;
+exports.createPaginatedSchema = createPaginatedSchema;
+exports.validateResponse = validateResponse;
+exports.validateResponseSafe = validateResponseSafe;
+/* eslint-disable jsdoc/reject-any-type */
+/* eslint-disable jsdoc/no-undefined-types */
+const zod_1 = require("zod");
+/**
+ * Common validation schemas for API responses
+ * @description Base schemas that can be reused across different modules
+ */
+/**
+ * Error response schema
+ */
+exports.ErrorSchema = zod_1.z.object({
+    statusCode: zod_1.z.number(),
+    message: zod_1.z.string(),
+    localizeMessage: zod_1.z.string().optional(),
+});
+/**
+ * Localize info schema
+ */
+exports.LocalizeInfoSchema = zod_1.z.object({
+    title: zod_1.z.string(),
+    content: zod_1.z.string().optional(),
+    menuTitle: zod_1.z.string().optional(),
+});
+/**
+ * Attribute schema
+ */
+exports.AttributeSchema = zod_1.z.object({
+    id: zod_1.z.number().optional(),
+    marker: zod_1.z.string(),
+    type: zod_1.z.string(),
+    isVisible: zod_1.z.boolean().optional(),
+    isRequired: zod_1.z.boolean().optional(),
+    position: zod_1.z.number().optional(),
+    localizeInfos: zod_1.z.record(zod_1.z.string(), exports.LocalizeInfoSchema).optional(),
+    value: zod_1.z.any().optional(),
+});
+/**
+ * User entity schema
+ */
+exports.UserEntitySchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    identifier: zod_1.z.string().optional(),
+    email: zod_1.z.string().email().optional(),
+    phoneMask: zod_1.z.string().optional(),
+    phoneCode: zod_1.z.string().optional(),
+    phoneNumber: zod_1.z.string().optional(),
+    statusMarker: zod_1.z.string().optional(),
+    formData: zod_1.z
+        .union([zod_1.z.array(zod_1.z.any()), zod_1.z.record(zod_1.z.string(), zod_1.z.any())])
+        .optional(),
+    total: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional(),
+    authProviderIdentifier: zod_1.z.string().optional(),
+    formIdentifier: zod_1.z.string().optional(),
+    groups: zod_1.z.array(zod_1.z.number()).optional(),
+    state: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
+    moduleFormConfigs: zod_1.z.array(zod_1.z.any()).optional(),
+});
+/**
+ * Auth entity schema
+ * API returns only accessToken and refreshToken
+ * userIdentifier and authProviderIdentifier are optional legacy fields
+ */
+exports.AuthEntitySchema = zod_1.z.object({
+    accessToken: zod_1.z.string(),
+    refreshToken: zod_1.z.string(),
+    userIdentifier: zod_1.z.string().optional(),
+    authProviderIdentifier: zod_1.z.string().optional(),
+    user: exports.UserEntitySchema.optional(),
+});
+/**
+ * Paginated response schema factory
+ * @param {T} itemSchema - The schema for each item in the paginated response
+ * @returns {any} Paginated response schema
+ */
+function createPaginatedSchema(itemSchema) {
+    return zod_1.z.object({
+        items: zod_1.z.array(itemSchema),
+        total: zod_1.z.number(),
+        page: zod_1.z.number().optional(),
+        limit: zod_1.z.number().optional(),
+    });
+}
+/**
+ * Validation helper function
+ * @param {z.ZodSchema<T>} schema - Zod schema to validate against
+ * @param {unknown} data - Data to validate
+ * @param {object} options - Validation options
+ * @param {boolean} options.strict - Whether to use strict mode
+ * @param {boolean} options.logErrors - Whether to log errors
+ * @returns {object} Validated data or error
+ */
+function validateResponse(schema, data, options) {
+    try {
+        const validated = schema.parse(data);
+        return { success: true, data: validated };
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            if (options === null || options === void 0 ? void 0 : options.logErrors) {
+                // eslint-disable-next-line no-undef, no-console
+                console.error('Validation error:', {
+                    errors: error.issues,
+                    data,
+                });
+            }
+            return { success: false, error };
+        }
+        throw error;
+    }
+}
+/**
+ * Safe validation helper - returns data even if validation fails
+ * Used when strict mode is disabled
+ * @param {z.ZodSchema<T>} schema - Zod schema to validate against
+ * @param {unknown} data - Data to validate
+ * @param {boolean} logErrors - Whether to log errors
+ * @returns {T} Validated data or original data if validation fails in non-strict mode
+ */
+function validateResponseSafe(schema, data, logErrors = false) {
+    const result = validateResponse(schema, data, { logErrors });
+    if (result.success) {
+        return result.data;
+    }
+    // Return original data if validation fails in non-strict mode
+    return data;
+}