oneentry 1.0.175 → 1.0.177

package/dist/web-socket/lazySocket.d.ts

@@ -8,11 +8,12 @@ import type { Socket } from 'socket.io-client';
  * queued and replayed onto the real socket as soon as the chunk resolves, and every later
  * call passes straight through.
  * @param {() => Promise<Socket>} createSocket - Loads Socket.io and creates the socket.
- * @returns {Socket} Stand-in usable exactly like the socket it will become.
+ * @returns {Socket} Stand-in usable like the socket it will become.
  * @description Listener registration is what matters for ordering, and it is safe: the queue is
  * replayed in the same tick the socket is created, before the connection can deliver anything.
- * The one visible difference is that methods returning a value (e.g. `listeners()`) cannot answer
- * before the chunk arrives — they return the proxy instead. Reading state (`id`, `connected`, …)
- * is accurate, and awaiting `socket.io` or other nested objects is only possible once loaded.
+ * Before the chunk arrives: `emitWithAck` returns a Promise settled by the real socket,
+ * `hasListeners`/`listeners` answer from the queued listeners, `socket.io.on(…)` and `volatile` are
+ * queued, assignments (e.g. `socket.auth = …`) are applied to the real socket, and other properties
+ * read `undefined`. A failed chunk load is reported to the `connect_error` listeners.
  */
-export default function createLazySocket(createSocket: () => Promise<Socket>): Socket;
+export default function createLazySocket<S extends Socket = Socket>(createSocket: () => Promise<S>): S;

package/dist/web-socket/lazySocket.js

@@ -10,9 +10,41 @@ const PENDING_STATE = {
     id: undefined,
     connected: false,
     disconnected: true,
-    active: false,
+    // A socket created with `autoConnect` is active from the start
+    active: true,
     recovered: false,
 };
+/**
+ * Socket methods that may be called before the real socket exists: they are queued and replayed.
+ * @description Any other property read early answers `undefined`. Queuing every name used to put
+ * `toJSON` (read by `JSON.stringify`) into the queue, and its replay threw and lost every listener.
+ */
+const QUEUEABLE = new Set([
+    'on',
+    'once',
+    'off',
+    'addListener',
+    'removeListener',
+    'removeAllListeners',
+    'onAny',
+    'prependAny',
+    'offAny',
+    'onAnyOutgoing',
+    'prependAnyOutgoing',
+    'offAnyOutgoing',
+    'emit',
+    'send',
+    'connect',
+    'open',
+    'disconnect',
+    'close',
+    'compress',
+    'timeout',
+]);
+/**
+ * Methods of `socket.io` (the Manager) that may be called before the real socket exists.
+ */
+const IO_QUEUEABLE = new Set(['on', 'once', 'off', 'reconnection']);
 /**
  * Wraps a not-yet-loaded Socket.io socket in a synchronous stand-in.
  *
@@ -22,30 +54,108 @@ const PENDING_STATE = {
  * queued and replayed onto the real socket as soon as the chunk resolves, and every later
  * call passes straight through.
  * @param {() => Promise<Socket>} createSocket - Loads Socket.io and creates the socket.
- * @returns {Socket} Stand-in usable exactly like the socket it will become.
+ * @returns {Socket} Stand-in usable like the socket it will become.
  * @description Listener registration is what matters for ordering, and it is safe: the queue is
  * replayed in the same tick the socket is created, before the connection can deliver anything.
- * The one visible difference is that methods returning a value (e.g. `listeners()`) cannot answer
- * before the chunk arrives — they return the proxy instead. Reading state (`id`, `connected`, …)
- * is accurate, and awaiting `socket.io` or other nested objects is only possible once loaded.
+ * Before the chunk arrives: `emitWithAck` returns a Promise settled by the real socket,
+ * `hasListeners`/`listeners` answer from the queued listeners, `socket.io.on(…)` and `volatile` are
+ * queued, assignments (e.g. `socket.auth = …`) are applied to the real socket, and other properties
+ * read `undefined`. A failed chunk load is reported to the `connect_error` listeners.
  */
 function createLazySocket(createSocket) {
     let socket;
+    let loadError;
     const queued = [];
+    const pendingProps = new Map();
+    // The listeners the queue leaves registered, `off`/`removeAllListeners` applied in order
+    const queuedListeners = (event) => {
+        let listeners = [];
+        for (const { target, method, args } of queued) {
+            if (target !== 'socket')
+                continue;
+            if (method === 'on' || method === 'once' || method === 'addListener') {
+                listeners.push({
+                    event: args[0],
+                    fn: args[1],
+                });
+            }
+            else if (method === 'off' || method === 'removeListener') {
+                // `off()` without arguments removes every listener, as in Socket.io
+                listeners = listeners.filter((l) => (args.length > 0 && l.event !== args[0]) ||
+                    (args.length > 1 && l.fn !== args[1]));
+            }
+            else if (method === 'removeAllListeners') {
+                listeners = listeners.filter((l) => args.length > 0 && l.event !== args[0]);
+            }
+        }
+        return listeners
+            .filter((l) => event === undefined || l.event === event)
+            .map((l) => l.fn);
+    };
     const loading = createSocket().then((created) => {
+        // Assigned first: a listener running during the replay already reaches the real socket
+        socket = created;
+        for (const [property, value] of pendingProps) {
+            created[property] = value;
+        }
+        pendingProps.clear();
         // Replay before returning: the connection cannot emit anything until this tick ends,
-        // so no event registered through the proxy can be missed.
-        for (const { method, args } of queued) {
-            created[method](...args);
+        // so no event registered through the proxy can be missed. One failing call must not
+        // drop the rest of the queue.
+        for (const { target, method, args } of queued) {
+            try {
+                const owner = target === 'io' ? created.io : created;
+                if (method === 'volatile') {
+                    void owner.volatile;
+                }
+                else if (method === 'emitWithAck') {
+                    // Replayed in its place in the queue: a `timeout()` queued before it is its own flag
+                    const { resolve, reject } = args.pop();
+                    owner.emitWithAck(...args).then(resolve, reject);
+                }
+                else {
+                    owner[method](...args);
+                }
+            }
+            catch (error) {
+                // eslint-disable-next-line no-undef, no-console
+                console.error(`OneEntry SDK: socket.${method}() failed`, error);
+            }
         }
         queued.length = 0;
-        socket = created;
         return created;
     });
-    // A failed chunk load must not surface as an unhandled rejection
+    // A failed chunk load must not surface as an unhandled rejection: it goes to the
+    // `connect_error` listeners, the place Socket.io reports a connection that cannot open
     loading.catch((error) => {
-        // eslint-disable-next-line no-undef, no-console
-        console.error('OneEntry SDK: failed to load socket.io-client', error);
+        loadError = error;
+        const listeners = queuedListeners('connect_error');
+        for (const { method, args } of queued) {
+            if (method === 'emitWithAck') {
+                args[args.length - 1].reject(error);
+            }
+        }
+        queued.length = 0;
+        if (listeners.length === 0) {
+            // eslint-disable-next-line no-undef, no-console
+            console.error('OneEntry SDK: could not create the socket', error);
+        }
+        for (const listener of listeners) {
+            listener(error);
+        }
+    });
+    const ioProxy = new Proxy({}, {
+        get(_target, property) {
+            if (typeof property === 'string' && IO_QUEUEABLE.has(property)) {
+                return (...args) => {
+                    if (!loadError) {
+                        queued.push({ target: 'io', method: property, args });
+                    }
+                    return ioProxy;
+                };
+            }
+            return undefined;
+        },
     });
     const proxy = new Proxy({}, {
         get(_target, property) {
@@ -57,13 +167,100 @@ function createLazySocket(createSocket) {
             if (property === 'then' || typeof property === 'symbol') {
                 return undefined;
             }
+            if (pendingProps.has(property)) {
+                return pendingProps.get(property);
+            }
+            if (property === 'active') {
+                // Active until a queued disconnect or a failed load, as the real socket would be
+                // The last queued connect/disconnect decides, as on the real socket
+                const last = [...queued]
+                    .reverse()
+                    .find(({ target, method }) => target === 'socket' &&
+                    ['disconnect', 'close', 'connect', 'open'].includes(method));
+                return (!loadError &&
+                    !(last && (last.method === 'disconnect' || last.method === 'close')));
+            }
             if (property in PENDING_STATE) {
                 return PENDING_STATE[property];
             }
-            return (...args) => {
-                queued.push({ method: property, args });
+            if (property === 'io') {
+                return ioProxy;
+            }
+            if (property === 'volatile') {
+                if (!loadError) {
+                    queued.push({ target: 'socket', method: 'volatile', args: [] });
+                }
                 return proxy;
-            };
+            }
+            if (property === 'emitWithAck') {
+                return (...args) => loadError
+                    ? Promise.reject(loadError)
+                    : new Promise((resolve, reject) => {
+                        queued.push({
+                            target: 'socket',
+                            method: 'emitWithAck',
+                            args: [...args, { resolve, reject }],
+                        });
+                    });
+            }
+            if (property === 'hasListeners') {
+                return (event) => queuedListeners(event).length > 0;
+            }
+            if (property === 'listeners') {
+                return (event) => queuedListeners(event);
+            }
+            if (typeof property === 'string' && QUEUEABLE.has(property)) {
+                return (...args) => {
+                    if (loadError &&
+                        (property === 'on' || property === 'once') &&
+                        args[0] === 'connect_error') {
+                        // Registered after the load already failed: report it straight away
+                        args[1](loadError);
+                    }
+                    else if (!loadError) {
+                        queued.push({ target: 'socket', method: property, args });
+                    }
+                    return proxy;
+                };
+            }
+            return undefined;
+        },
+        set(_target, property, value) {
+            if (socket) {
+                return Reflect.set(socket, property, value);
+            }
+            pendingProps.set(property, value);
+            return true;
+        },
+        has(_target, property) {
+            if (socket) {
+                return property in socket;
+            }
+            return (typeof property === 'string' &&
+                (property in PENDING_STATE ||
+                    QUEUEABLE.has(property) ||
+                    [
+                        'io',
+                        'volatile',
+                        'emitWithAck',
+                        'hasListeners',
+                        'listeners',
+                    ].includes(property) ||
+                    pendingProps.has(property)));
+        },
+        ownKeys() {
+            return socket ? Reflect.ownKeys(socket) : [];
+        },
+        getOwnPropertyDescriptor(_target, property) {
+            if (!socket) {
+                return undefined;
+            }
+            const descriptor = Reflect.getOwnPropertyDescriptor(socket, property);
+            // The proxy target holds none of these keys, so they must be reported configurable
+            return descriptor ? { ...descriptor, configurable: true } : undefined;
+        },
+        getPrototypeOf() {
+            return socket ? Reflect.getPrototypeOf(socket) : Object.prototype;
         },
     });
     return proxy;

package/dist/web-socket/wsApi.d.ts

@@ -1,7 +1,7 @@
 import type { Socket } from 'socket.io-client';
 import AsyncModules from '../base/asyncModules';
 import type StateModule from '../base/stateModule';
-import type { IWS } from './wsInterfaces';
+import type { IWS, IWsServerEvents } from './wsInterfaces';
 /**
  * Controllers for working with users
  * @handle /api/content/ws
@@ -17,11 +17,14 @@ export default class WsApi extends AsyncModules implements IWS {
     /**
      * Creates an instance of an object Socket.io with a connection.
      * @handleName connect
-     * @returns {Socket} Returns a Socket instance.
-     * @description Creates an instance of an object Socket.io with a connection. This method requires user authorization.
+     * @returns {Socket<IWsServerEvents>} Returns a Socket instance.
+     * @description Opens a Socket.io connection. Without a signed-in user the socket is a guest and
+     * receives only notifications sent to everyone; personal ones need `AuthProvider.auth` first.
+     * The current access token is sent on every (re)connection, so a refreshed token is picked up.
+     * Every call opens a separate connection.
      * Socket.io is imported on demand, so projects that never open a socket do not bundle it; the returned
      * value is usable immediately either way (see `createLazySocket`).
      * @see {@link https://js-sdk.oneentry.cloud/docs/web-socket/connect connect} documentation.
      */
-    connect(): Socket;
+    connect(): Socket<IWsServerEvents>;
 }

package/dist/web-socket/wsApi.js

@@ -54,28 +54,65 @@ class WsApi extends asyncModules_1.default {
     /**
      * Creates an instance of an object Socket.io with a connection.
      * @handleName connect
-     * @returns {Socket} Returns a Socket instance.
-     * @description Creates an instance of an object Socket.io with a connection. This method requires user authorization.
+     * @returns {Socket<IWsServerEvents>} Returns a Socket instance.
+     * @description Opens a Socket.io connection. Without a signed-in user the socket is a guest and
+     * receives only notifications sent to everyone; personal ones need `AuthProvider.auth` first.
+     * The current access token is sent on every (re)connection, so a refreshed token is picked up.
+     * Every call opens a separate connection.
      * Socket.io is imported on demand, so projects that never open a socket do not bundle it; the returned
      * value is usable immediately either way (see `createLazySocket`).
      * @see {@link https://js-sdk.oneentry.cloud/docs/web-socket/connect connect} documentation.
      */
     connect() {
-        if (!this.state.accessToken) {
-            // eslint-disable-next-line no-undef, no-console
-            console.error('User is unauthorized');
-        }
         return (0, lazySocket_1.default)(async () => {
+            var _a;
             const { io } = await Promise.resolve().then(() => __importStar(require('socket.io-client')));
-            return io(this.state.url, {
+            // A session restored from a refresh token has no access token until its first
+            // request: the socket went out as a guest. Obtain it first, as REST calls do.
+            if (!this.state.accessToken &&
+                this._canRefresh() &&
+                !this.state.customAuth) {
+                await this.refreshToken();
+            }
+            // A path in the project URL (a reverse proxy prefix) belongs to the socket path:
+            // passed in the URL, Socket.io read it as a namespace and answered "Invalid namespace"
+            // A proxy path (`/oneentry`) resolves against the page
+            // `''` (the site root proxy) must not resolve to the current page's path
+            const base = new URL(this.state.url || '/', (_a = globalThis.location) === null || _a === void 0 ? void 0 : _a.href);
+            const path = base.pathname.replace(/\/+$/, '') + '/api/content/ws';
+            // The platform registers a user only with both the bearer and `x-device-metadata`;
+            // without the latter every SDK socket was a guest. Read on each (re)connection so a
+            // refreshed token is used, and no `Bearer undefined` for a guest.
+            const headers = () => ({
+                ...(this.state.accessToken
+                    ? { Authorization: 'Bearer ' + this.state.accessToken }
+                    : {}),
+                'x-app-token': this.state.token,
+                'x-device-metadata': this._getDeviceMetadata(),
+            });
+            const socket = io(base.origin, {
                 autoConnect: true,
-                path: '/api/content/ws',
+                path,
                 transports: ['websocket'],
-                extraHeaders: {
-                    Authorization: 'Bearer ' + this.state.accessToken,
-                    'x-app-token': this.state.token,
-                },
+                // Browsers drop `extraHeaders` on a WebSocket: the same data goes in the
+                // handshake `auth` payload as well
+                extraHeaders: headers(),
+                auth: (cb) => cb({
+                    token: this.state.accessToken,
+                    appToken: this.state.token,
+                    deviceMetadata: this._getDeviceMetadata(),
+                }),
             });
+            // Every connection — automatic reconnection or a manual `socket.connect()` after
+            // `disconnect()` — goes through `Manager.open`, which builds the transport from
+            // `opts`: refresh the headers there, or a sign-in after the first connect never reached it
+            const manager = socket.io;
+            const open = manager.open.bind(manager);
+            manager.open = (...args) => {
+                manager.opts.extraHeaders = headers();
+                return open(...args);
+            };
+            return socket;
         });
     }
 }

package/dist/web-socket/wsInterfaces.d.ts

@@ -1,4 +1,39 @@
 import type { Socket } from 'socket.io-client';
+/**
+ * @interface IWsNotificationAttribute
+ * @property {string} identifier - Attribute marker. Example: "title".
+ * @property {string} type - Attribute type. Example: "string".
+ * @property {unknown} value - Attribute value as the platform sent it.
+ * @description An attribute carried by a notification.
+ */
+interface IWsNotificationAttribute {
+    identifier: string;
+    type: string;
+    value: unknown;
+}
+/**
+ * @interface IWsNotification
+ * @property {string} message - Notification text; an empty string when the event has none.
+ * @property {string} [type] - What the notification is about. Example: "product", "order", "user", "form", "refund".
+ * @property {IWsNotificationAttribute[]} [attributes] - Attributes selected for the notification in the event settings.
+ * @description Payload of the `notification` event. Fields beyond `message` depend on the event
+ * (`product`, `order`, `user`, `formData`, …) and are typed `unknown` until checked.
+ */
+interface IWsNotification {
+    message: string;
+    type?: string;
+    attributes?: IWsNotificationAttribute[];
+    [key: string]: unknown;
+}
+/**
+ * @interface IWsServerEvents
+ * @property {function(IWsNotification): void} notification - Event notification sent by the platform.
+ * @description Events the platform sends over the socket. Other event names stay untyped.
+ */
+interface IWsServerEvents {
+    notification: (payload: IWsNotification) => void;
+    [event: string]: (...args: any[]) => void;
+}
 /**
  * @interface IWS
  * @description This interface defines a method for establishing a WebSocket connection.
@@ -7,10 +42,12 @@ interface IWS {
     /**
      * Creates an instance of an object Socket.io with a connection.
      * @handleName connect
-     * @returns {Socket} Returns a Socket instance.
-     * @description Creates an instance of an object Socket.io with a connection. This method requires user authorization.
+     * @returns {Socket<IWsServerEvents>} Returns a Socket instance.
+     * @description Opens a Socket.io connection. Without a signed-in user the socket is a guest and
+     * receives only notifications sent to everyone; personal ones need `AuthProvider.auth` first.
+     * Every call opens a separate connection.
      * @see For more information about configuring the {@link https://js-sdk.oneentry.cloud/docs/category/authprovider authorization module}, see the documentation in the  {@link https://js-sdk.oneentry.cloud/docs/category/authprovider configuration settings section of the SDK}.
      */
-    connect(): Socket;
+    connect(): Socket<IWsServerEvents>;
 }
-export type { IWS };
+export type { IWS, IWsNotification, IWsNotificationAttribute, IWsServerEvents };

package/esm/admins/adminsApi.js

@@ -77,14 +77,7 @@ export default class AdminsApi extends AsyncModules {
             offset,
             limit,
         };
-        const savedUrl = this._url;
-        this._url = this._adminsUrl;
-        try {
-            const response = await this._fetchPost(`/vector/search?` + this._queryParamsToString(query), body);
-            return this._normalizeData(response, langCode);
-        }
-        finally {
-            this._url = savedUrl;
-        }
+        const response = await this._withBaseUrl(this._adminsUrl)._fetchPost(`/vector/search?` + this._queryParamsToString(query), body);
+        return this._normalizeData(response, langCode);
     }
 }

package/esm/admins/adminsInterfaces.d.ts

@@ -94,10 +94,10 @@ interface IPosition {
  * @interface IAdminEntity
  * @property {number} id - Object ID. Example: 1764.
  * @property {number | null} attributeSetId - ID of the attribute set in use. Example: 120.
- * @property {string} identifier - Text identifier (marker) of the object. Example: "admin1".
+ * @property {string} [identifier] - Not returned by the Content API: it was the admin's sign-in login, and the platform no longer sends it. Kept optional for compatibility.
  * @property {string | null} attributeSetIdentifier - Marker of the attribute set. Example: "admins".
  * @property {number | null} position - Position used for sorting. Example: 1.
- * @property {boolean} isSync - Whether the page is indexed. Example: true.
+ * @property {boolean} isSync - Whether the admin has attribute data in the requested language (`false` with empty `attributeValues` otherwise). Example: true.
  * @property {IAttributeValues} attributeValues - Attribute values keyed by attribute marker.
  * @example
     [
@@ -108,19 +108,19 @@ interface IPosition {
         }
       }
     ]
- * @property {IFormConfig[]} [moduleFormConfigs] - Form configurations of the module associated with the admin.
+ * @property {IFormConfig[]} [formModuleConfigs] - Form configurations of the module associated with the admin (the API key is `formModuleConfigs`). Example: [].
  * @property {number} [distance] - Cosine distance to the query. Returned only by the semantic (vector) search endpoint when `debug: true` is passed in the search body. Example: 0.12.
  * @description This interface captures the essential details and additional attributes of an admin entity.
  */
 interface IAdminEntity {
     id: number;
     attributeSetId: number | null;
-    identifier: string;
+    identifier?: string;
     attributeSetIdentifier: string | null;
     position: number | null;
     isSync: boolean;
     attributeValues: IAttributeValues;
-    moduleFormConfigs?: IFormConfig[];
+    formModuleConfigs?: IFormConfig[];
     distance?: number;
 }
 /**

package/esm/admins/adminsSchemas.d.ts

@@ -10,12 +10,12 @@ import { z } from 'zod';
 export declare const AdminEntitySchema: z.ZodObject<{
     id: z.ZodNumber;
     attributeSetId: z.ZodNullable<z.ZodNumber>;
-    identifier: z.ZodString;
+    identifier: z.ZodOptional<z.ZodString>;
     attributeSetIdentifier: z.ZodNullable<z.ZodString>;
     position: z.ZodNullable<z.ZodNumber>;
     isSync: z.ZodBoolean;
     attributeValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    moduleFormConfigs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    formModuleConfigs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
     distance: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 /**
@@ -24,11 +24,11 @@ export declare const AdminEntitySchema: z.ZodObject<{
 export declare const AdminsResponseSchema: z.ZodArray<z.ZodObject<{
     id: z.ZodNumber;
     attributeSetId: z.ZodNullable<z.ZodNumber>;
-    identifier: z.ZodString;
+    identifier: z.ZodOptional<z.ZodString>;
     attributeSetIdentifier: z.ZodNullable<z.ZodString>;
     position: z.ZodNullable<z.ZodNumber>;
     isSync: z.ZodBoolean;
     attributeValues: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    moduleFormConfigs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    formModuleConfigs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
     distance: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>>;

package/esm/admins/adminsSchemas.js

@@ -11,12 +11,12 @@ import { AttributeValuesSchema } from '../base/validation.js';
 export const AdminEntitySchema = z.object({
     id: z.number(),
     attributeSetId: z.number().nullable(),
-    identifier: z.string(),
+    identifier: z.string().optional(),
     attributeSetIdentifier: z.string().nullable(),
     position: z.number().nullable(),
     isSync: z.boolean(),
     attributeValues: AttributeValuesSchema,
-    moduleFormConfigs: z.array(z.any()).optional(),
+    formModuleConfigs: z.array(z.any()).optional(),
     distance: z.number().optional(),
 });
 /**

package/esm/attribute-sets/attributeSetsApi.d.ts

@@ -27,7 +27,7 @@ export default class AttributesSetsApi extends AsyncModules implements IAttribut
      * @param {number} [offset] - Number of records to skip. Default: 0.
      * @param {number} [limit] - Maximum number of records to return. Default: 30.
      * @param {number} [typeId] - ID of the attribute set type to filter by. Default: null.
-     * @param {string} [sortBy] - Field to sort by: `id` or `position`. Default: "id".
+     * @param {string} [sortBy] - Field to sort by: `id` (descending) or `position`. Default: "id".
      * @returns {Promise<IAttributesSetsResponse | IError>} Returns object with array of IAttributeSetsEntity and total items count.
      * @throws {IError} When isShell=false and an error occurs during the fetch
      * @see {@link https://js-sdk.oneentry.cloud/docs/attribute-sets/getAttributes getAttributes} documentation.

package/esm/attribute-sets/attributeSetsApi.js

@@ -27,7 +27,7 @@ export default class AttributesSetsApi extends AsyncModules {
      * @param {number} [offset] - Number of records to skip. Default: 0.
      * @param {number} [limit] - Maximum number of records to return. Default: 30.
      * @param {number} [typeId] - ID of the attribute set type to filter by. Default: null.
-     * @param {string} [sortBy] - Field to sort by: `id` or `position`. Default: "id".
+     * @param {string} [sortBy] - Field to sort by: `id` (descending) or `position`. Default: "id".
      * @returns {Promise<IAttributesSetsResponse | IError>} Returns object with array of IAttributeSetsEntity and total items count.
      * @throws {IError} When isShell=false and an error occurs during the fetch
      * @see {@link https://js-sdk.oneentry.cloud/docs/attribute-sets/getAttributes getAttributes} documentation.
@@ -58,7 +58,7 @@ export default class AttributesSetsApi extends AsyncModules {
      * @see {@link https://js-sdk.oneentry.cloud/docs/attribute-sets/getAttributesByMarker getAttributesByMarker} documentation.
      */
     async getAttributesByMarker(marker, langCode = this.state.lang) {
-        const result = await this._fetchGet(`/${marker}/attributes?langCode=${langCode}`);
+        const result = await this._fetchGet(`/${this._pathSegment(marker)}/attributes?langCode=${encodeURIComponent(langCode)}`);
         // Validate response if validation is enabled
         const validated = await this._validateResponse(result, schema('AttributesArrayResponseSchema'));
         return this._normalizeData(validated, langCode);
@@ -74,7 +74,7 @@ export default class AttributesSetsApi extends AsyncModules {
      * @see {@link https://js-sdk.oneentry.cloud/docs/attribute-sets/getSingleAttributeByMarkerSet getSingleAttributeByMarkerSet} documentation.
      */
     async getSingleAttributeByMarkerSet(setMarker, attributeMarker, langCode = this.state.lang) {
-        const result = await this._fetchGet(`/${setMarker}/attributes/${attributeMarker}?langCode=${langCode}`);
+        const result = await this._fetchGet(`/${this._pathSegment(setMarker)}/attributes/${this._pathSegment(attributeMarker)}?langCode=${encodeURIComponent(langCode)}`);
         // Validate response if validation is enabled
         const validated = await this._validateResponse(result, schema('AttributeEntitySchema'));
         return this._normalizeData(validated, langCode);
@@ -89,7 +89,7 @@ export default class AttributesSetsApi extends AsyncModules {
      * @see {@link https://js-sdk.oneentry.cloud/docs/attribute-sets/getAttributeSetByMarker getAttributeSetByMarker} documentation.
      */
     async getAttributeSetByMarker(marker, langCode = this.state.lang) {
-        const result = await this._fetchGet(`/marker/${marker}?langCode=${langCode}`);
+        const result = await this._fetchGet(`/marker/${this._pathSegment(marker)}?langCode=${encodeURIComponent(langCode)}`);
         // Validate response if validation is enabled
         const validated = await this._validateResponse(result, schema('AttributeSetEntitySchema'));
         return this._normalizeData(validated, langCode);