@technomoron/api-server-base 1.1.13 → 2.0.0-beta.2

package/dist/esm/token/sequelize.js

@@ -0,0 +1,400 @@
+import { DataTypes, Model, Op } from 'sequelize';
+import { TokenStore } from './base.js';
+const DIALECTS_SUPPORTING_UNSIGNED = new Set(['mysql', 'mariadb']);
+class TokenModel extends Model {
+}
+function tokenTableOptions(sequelize) {
+    const opts = {
+        sequelize,
+        tableName: 'jwttokens',
+        timestamps: false
+    };
+    if (DIALECTS_SUPPORTING_UNSIGNED.has(sequelize.getDialect())) {
+        opts.charset = 'utf8mb4';
+        opts.collate = 'utf8mb4_unicode_ci';
+    }
+    return opts;
+}
+function initTokenModel(sequelize) {
+    TokenModel.init({
+        token_id: {
+            type: DIALECTS_SUPPORTING_UNSIGNED.has(sequelize.getDialect())
+                ? DataTypes.INTEGER.UNSIGNED
+                : DataTypes.INTEGER,
+            autoIncrement: true,
+            allowNull: false,
+            primaryKey: true
+        },
+        user_id: {
+            type: DataTypes.STRING(191),
+            allowNull: false
+        },
+        real_user_id: {
+            type: DataTypes.STRING(191),
+            allowNull: true,
+            defaultValue: null
+        },
+        expires: {
+            type: DataTypes.DATE,
+            allowNull: false
+        },
+        issued_at: {
+            type: DataTypes.DATE,
+            allowNull: false,
+            defaultValue: DataTypes.NOW
+        },
+        last_seen_at: {
+            type: DataTypes.DATE,
+            allowNull: false,
+            defaultValue: DataTypes.NOW
+        },
+        access: {
+            type: DataTypes.STRING(512),
+            allowNull: false
+        },
+        refresh: {
+            type: DataTypes.STRING(512),
+            allowNull: false
+        },
+        domain: {
+            type: DataTypes.STRING(64),
+            allowNull: false,
+            defaultValue: ''
+        },
+        fingerprint: {
+            type: DataTypes.STRING(64),
+            allowNull: false,
+            defaultValue: ''
+        },
+        label: {
+            type: DataTypes.STRING(128),
+            allowNull: false,
+            defaultValue: ''
+        },
+        browser: {
+            type: DataTypes.STRING(64),
+            allowNull: false,
+            defaultValue: ''
+        },
+        device: {
+            type: DataTypes.STRING(64),
+            allowNull: false,
+            defaultValue: ''
+        },
+        ip: {
+            type: DataTypes.STRING(45),
+            allowNull: false,
+            defaultValue: ''
+        },
+        os: {
+            type: DataTypes.STRING(64),
+            allowNull: false,
+            defaultValue: ''
+        },
+        login_type: {
+            type: DataTypes.STRING(64),
+            allowNull: false,
+            defaultValue: ''
+        },
+        refresh_ttl_seconds: {
+            type: DataTypes.INTEGER,
+            allowNull: true,
+            defaultValue: null
+        },
+        session_cookie: {
+            type: DataTypes.BOOLEAN,
+            allowNull: false,
+            defaultValue: false
+        },
+        client_id: {
+            type: DataTypes.STRING(128),
+            allowNull: true,
+            defaultValue: null
+        },
+        scope: {
+            type: DataTypes.TEXT,
+            allowNull: false,
+            defaultValue: '[]'
+        }
+    }, {
+        ...tokenTableOptions(sequelize),
+        indexes: [
+            { name: 'jwt_access_unique', unique: true, fields: ['access'] },
+            { name: 'jwt_refresh_unique', unique: true, fields: ['refresh'] }
+        ]
+    });
+    return TokenModel;
+}
+export class SequelizeTokenStore extends TokenStore {
+    constructor(options) {
+        super();
+        if (!options?.sequelize) {
+            throw new Error('SequelizeTokenStore requires an initialised Sequelize instance');
+        }
+        this.Tokens = options.tokenModel ?? (options.tokenModelFactory ?? initTokenModel)(options.sequelize);
+    }
+    async save(record) {
+        const normalized = this.normalizeToken(record);
+        const resolvedUserId = this.normalizeUserId(normalized.userId);
+        const resolvedRealUserId = this.resolveRealUserId(normalized.ruid);
+        const domain = normalized.domain;
+        const fingerprint = normalized.fingerprint;
+        const browser = normalized.browser;
+        const device = normalized.device;
+        const ip = normalized.ip;
+        const os = normalized.os;
+        const label = normalized.label;
+        const loginType = normalized.loginType ?? '';
+        const refreshTtlSeconds = typeof normalized.refreshTtlSeconds === 'number' && normalized.refreshTtlSeconds > 0
+            ? Math.floor(normalized.refreshTtlSeconds)
+            : null;
+        const issuedAt = normalized.issuedAt ?? new Date();
+        const lastSeenAt = normalized.lastSeenAt ?? issuedAt;
+        const sessionCookie = normalized.sessionCookie ?? false;
+        const removalWhere = { user_id: resolvedUserId };
+        if (normalized.domain !== undefined && record.domain !== undefined) {
+            removalWhere.domain = domain;
+        }
+        if (normalized.fingerprint !== undefined && record.fingerprint !== undefined) {
+            removalWhere.fingerprint = fingerprint;
+        }
+        if (normalized.clientId) {
+            removalWhere.client_id = normalized.clientId;
+        }
+        await this.Tokens.destroy({ where: removalWhere });
+        await this.Tokens.create({
+            user_id: resolvedUserId,
+            real_user_id: resolvedRealUserId,
+            access: normalized.accessToken ?? '',
+            refresh: normalized.refreshToken,
+            expires: normalized.expires,
+            issued_at: issuedAt,
+            last_seen_at: lastSeenAt,
+            domain,
+            fingerprint,
+            label,
+            browser,
+            device,
+            ip,
+            os,
+            client_id: normalized.clientId ?? null,
+            scope: this.encodeScope(normalized.scope),
+            login_type: loginType,
+            refresh_ttl_seconds: refreshTtlSeconds,
+            session_cookie: sessionCookie
+        });
+    }
+    async get(query, opts) {
+        if (!query.refreshToken && !query.accessToken && query.userId === undefined) {
+            throw new Error('At least one token lookup field must be provided');
+        }
+        const where = {};
+        if (query.refreshToken) {
+            where.refresh = query.refreshToken;
+        }
+        if (query.accessToken) {
+            where.access = query.accessToken;
+        }
+        if (query.userId !== undefined) {
+            where.user_id = this.normalizeUserId(query.userId);
+        }
+        if (query.clientId) {
+            where.client_id = query.clientId;
+        }
+        if (query.domain !== undefined && query.domain !== null) {
+            where.domain = query.domain;
+        }
+        if (query.fingerprint !== undefined && query.fingerprint !== null) {
+            where.fingerprint = query.fingerprint;
+        }
+        if (query.label) {
+            where.label = query.label;
+        }
+        if (!(opts?.includeExpired ?? false)) {
+            where.expires = { [Op.gt]: new Date() };
+        }
+        const model = await this.Tokens.findOne({ where });
+        return model ? this.toTokenRecord(model) : null;
+    }
+    async delete(query) {
+        if (!query.refreshToken && !query.accessToken && query.userId === undefined && !query.clientId) {
+            return 0;
+        }
+        const where = {};
+        if (query.refreshToken) {
+            where.refresh = query.refreshToken;
+        }
+        if (query.accessToken) {
+            where.access = query.accessToken;
+        }
+        if (query.userId !== undefined) {
+            where.user_id = this.normalizeUserId(query.userId);
+        }
+        if (query.clientId) {
+            where.client_id = query.clientId;
+        }
+        if (query.domain !== undefined && query.domain !== null) {
+            where.domain = query.domain;
+        }
+        if (query.fingerprint !== undefined && query.fingerprint !== null) {
+            where.fingerprint = query.fingerprint;
+        }
+        if (query.label) {
+            where.label = query.label;
+        }
+        return this.Tokens.destroy({ where });
+    }
+    async update(params) {
+        const where = { refresh: params.refreshToken };
+        if (params.clientId) {
+            where.client_id = params.clientId;
+        }
+        const updates = {};
+        if (params.accessToken !== undefined) {
+            updates.access = params.accessToken ?? null;
+        }
+        if (params.expires !== undefined) {
+            updates.expires = params.expires ?? null;
+        }
+        if (params.scope !== undefined) {
+            updates.scope = this.encodeScope(params.scope);
+        }
+        if (params.label !== undefined) {
+            updates.label = params.label ?? '';
+        }
+        if (params.domain !== undefined) {
+            updates.domain = params.domain ?? '';
+        }
+        if (params.fingerprint !== undefined) {
+            updates.fingerprint = params.fingerprint ?? '';
+        }
+        if (params.browser !== undefined) {
+            updates.browser = params.browser ?? '';
+        }
+        if (params.device !== undefined) {
+            updates.device = params.device ?? '';
+        }
+        if (params.ip !== undefined) {
+            updates.ip = params.ip ?? '';
+        }
+        if (params.os !== undefined) {
+            updates.os = params.os ?? '';
+        }
+        if (params.refreshTtlSeconds !== undefined) {
+            updates.refresh_ttl_seconds =
+                typeof params.refreshTtlSeconds === 'number' && params.refreshTtlSeconds > 0
+                    ? Math.floor(params.refreshTtlSeconds)
+                    : null;
+        }
+        if (params.loginType !== undefined) {
+            updates.login_type = params.loginType ?? '';
+        }
+        if (params.sessionCookie !== undefined) {
+            updates.session_cookie = params.sessionCookie;
+        }
+        if (params.issuedAt !== undefined) {
+            updates.issued_at = params.issuedAt ?? null;
+        }
+        if (params.lastSeenAt !== undefined) {
+            updates.last_seen_at = params.lastSeenAt ?? null;
+        }
+        if (Object.keys(updates).length === 0) {
+            return false;
+        }
+        const [updated] = await this.Tokens.update(updates, { where });
+        return updated > 0;
+    }
+    async list(userId, opts = {}) {
+        const where = { user_id: this.normalizeUserId(userId) };
+        if (!(opts.includeExpired ?? false)) {
+            where.expires = { [Op.gt]: new Date() };
+        }
+        const models = await this.Tokens.findAll({
+            where,
+            order: [['issued_at', 'DESC']],
+            limit: opts.limit,
+            offset: opts.offset
+        });
+        return models.map((model) => this.toTokenRecord(model));
+    }
+    async close() {
+        return;
+    }
+    normalizeUserId(identifier) {
+        if (identifier === undefined || identifier === null) {
+            throw new Error(`Unable to normalise user identifier: ${identifier}`);
+        }
+        return String(identifier);
+    }
+    resolveRealUserId(ruid) {
+        if (ruid === undefined || ruid === null) {
+            return null;
+        }
+        const value = String(ruid);
+        if (value.length === 0 || value === '0') {
+            return null;
+        }
+        return value;
+    }
+    encodeStringArray(values) {
+        return JSON.stringify(values ?? []);
+    }
+    decodeStringArray(raw) {
+        if (!raw) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                return parsed.filter((entry) => typeof entry === 'string' && entry.length > 0);
+            }
+        }
+        catch {
+            // ignore malformed values
+        }
+        return raw
+            .split(/\s+/)
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0);
+    }
+    encodeScope(scope) {
+        if (!scope || (Array.isArray(scope) && scope.length === 0)) {
+            return '[]';
+        }
+        if (Array.isArray(scope)) {
+            return this.encodeStringArray(scope);
+        }
+        return this.encodeStringArray(scope.split(/\s+/).filter((entry) => entry.length > 0));
+    }
+    decodeScope(raw) {
+        return this.decodeStringArray(raw);
+    }
+    toTokenRecord(model) {
+        const scope = this.decodeScope(model.scope);
+        const normalized = this.normalizeToken({
+            userId: model.user_id,
+            refreshToken: model.refresh,
+            accessToken: model.access,
+            expires: model.expires,
+            issuedAt: model.issued_at,
+            lastSeenAt: model.last_seen_at,
+            domain: model.domain,
+            fingerprint: model.fingerprint,
+            label: model.label,
+            browser: model.browser,
+            device: model.device,
+            ip: model.ip,
+            os: model.os,
+            clientId: model.client_id ?? undefined,
+            scope,
+            loginType: model.login_type || undefined,
+            refreshTtlSeconds: model.refresh_ttl_seconds ?? undefined,
+            ruid: model.real_user_id ?? undefined,
+            sessionCookie: model.session_cookie
+        });
+        return {
+            ...normalized,
+            scope: normalized.scope ? [...normalized.scope] : undefined
+        };
+    }
+}

package/dist/esm/token/types.d.ts

@@ -0,0 +1,27 @@
+export type TokenStatus = 'active' | 'expired' | 'revoked';
+export interface Token {
+    accessToken: string;
+    refreshToken: string;
+    userId: string;
+    expires?: Date;
+    issuedAt?: Date;
+    lastSeenAt?: Date;
+    status?: TokenStatus;
+    ruid?: string;
+    clientId?: string;
+    domain?: string;
+    fingerprint?: string;
+    label?: string;
+    browser?: string;
+    device?: string;
+    ip?: string;
+    os?: string;
+    scope?: string | string[];
+    loginType?: string;
+    refreshTtlSeconds?: number;
+    sessionCookie?: boolean;
+}
+export interface TokenPair {
+    accessToken: string;
+    refreshToken: string;
+}

package/dist/esm/token/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/user/base.d.ts

@@ -0,0 +1,26 @@
+import type { CreateUserInput, PublicUserMapper, UpdateUserInput } from './types.js';
+import type { AuthIdentifier } from '../auth-api/types.js';
+export declare abstract class UserStore<User, PublicUser> {
+    protected readonly toPublicUser: PublicUserMapper<User, PublicUser>;
+    private readonly bcryptRounds;
+    private readonly bcryptPepper?;
+    constructor(opts?: {
+        toPublic?: PublicUserMapper<User, PublicUser>;
+        bcryptRounds?: number;
+        bcryptPepper?: string;
+    });
+    protected hashPassword(plain: string): Promise<string>;
+    verifyPassword(plain: string, hashed: string): Promise<boolean>;
+    protected normalizeUserInput(input: Partial<CreateUserInput>): CreateUserInput;
+    abstract findUser(identifier: AuthIdentifier | string): Promise<User | null>;
+    abstract findById(id: AuthIdentifier): Promise<User | null>;
+    abstract findByLoginOrEmail(loginOrEmail: string): Promise<User | null>;
+    abstract createUser(input: CreateUserInput): Promise<User>;
+    abstract upsertUser(input: CreateUserInput): Promise<User>;
+    abstract updateUser(id: AuthIdentifier, patch: UpdateUserInput): Promise<User>;
+    abstract setPasswordHash(id: AuthIdentifier, hash: string): Promise<void>;
+    abstract getPasswordHash(user: User): string | null;
+    abstract getUserId(user: User): AuthIdentifier;
+    toPublic(user: User): PublicUser;
+}
+export type { CreateUserInput, UpdateUserInput, PublicUserMapper } from './types.js';

package/dist/esm/user/base.js

@@ -0,0 +1,38 @@
+import bcrypt from 'bcryptjs';
+export class UserStore {
+    constructor(opts = {}) {
+        this.toPublicUser = opts.toPublic ?? ((u) => u);
+        const rounds = typeof opts.bcryptRounds === 'number' && Number.isFinite(opts.bcryptRounds)
+            ? Math.max(4, Math.floor(opts.bcryptRounds))
+            : 12;
+        this.bcryptRounds = rounds;
+        this.bcryptPepper =
+            typeof opts.bcryptPepper === 'string' && opts.bcryptPepper.length > 0 ? opts.bcryptPepper : undefined;
+    }
+    async hashPassword(plain) {
+        const candidate = this.bcryptPepper ? `${plain}${this.bcryptPepper}` : plain;
+        return bcrypt.hash(candidate, this.bcryptRounds);
+    }
+    async verifyPassword(plain, hashed) {
+        const candidate = this.bcryptPepper ? `${plain}${this.bcryptPepper}` : plain;
+        return bcrypt.compare(candidate, hashed);
+    }
+    normalizeUserInput(input) {
+        const login = typeof input.login === 'string' ? input.login.trim() : '';
+        const email = typeof input.email === 'string' ? input.email.trim() : '';
+        if (!login || !email) {
+            throw new Error('login and email are required');
+        }
+        const password = typeof input.password === 'string' ? input.password : undefined;
+        return { ...input, login, email, password };
+    }
+    toPublic(user) {
+        const mapped = this.toPublicUser(user);
+        if (mapped && typeof mapped === 'object') {
+            const { password: _password, ...rest } = mapped;
+            void _password;
+            return rest;
+        }
+        return mapped;
+    }
+}

package/dist/esm/user/memory.d.ts

@@ -0,0 +1,35 @@
+import { UserStore } from './base.js';
+import type { CreateUserInput, PublicUserMapper, UpdateUserInput } from './types.js';
+import type { AuthIdentifier } from '../auth-api/types.js';
+export interface MemoryUserAttributes extends Record<string, unknown> {
+    user_id: number;
+    login: string;
+    email: string;
+    password: string;
+}
+export type MemoryPublicUser<UserAttributes extends MemoryUserAttributes = MemoryUserAttributes> = Omit<UserAttributes, 'password'>;
+export interface MemoryUserStoreOptions<UserAttributes extends MemoryUserAttributes = MemoryUserAttributes, PublicUserShape extends Omit<UserAttributes, 'password'> = Omit<UserAttributes, 'password'>> {
+    bcryptRounds?: number;
+    bcryptPepper?: string;
+    toPublic?: PublicUserMapper<UserAttributes, PublicUserShape>;
+    userIdFactory?: () => number;
+    startingUserId?: number;
+}
+export declare class MemoryUserStore<UserAttributes extends MemoryUserAttributes = MemoryUserAttributes, PublicUserShape extends Omit<UserAttributes, 'password'> = Omit<UserAttributes, 'password'>> extends UserStore<UserAttributes, PublicUserShape> {
+    private readonly usersById;
+    private readonly loginToId;
+    private readonly emailToId;
+    private readonly userIdFactory;
+    private nextUserId;
+    constructor(options?: MemoryUserStoreOptions<UserAttributes, PublicUserShape>);
+    findUser(identifier: AuthIdentifier | string): Promise<UserAttributes | null>;
+    findById(id: AuthIdentifier): Promise<UserAttributes | null>;
+    findByLoginOrEmail(loginOrEmail: string): Promise<UserAttributes | null>;
+    createUser(input: CreateUserInput): Promise<UserAttributes>;
+    upsertUser(input: CreateUserInput): Promise<UserAttributes>;
+    updateUser(id: AuthIdentifier, patch: UpdateUserInput): Promise<UserAttributes>;
+    setPasswordHash(id: AuthIdentifier, hash: string): Promise<void>;
+    getPasswordHash(user: UserAttributes): string | null;
+    getUserId(user: UserAttributes): AuthIdentifier;
+    private persistUser;
+}

package/dist/esm/user/memory.js

@@ -0,0 +1,169 @@
+import { UserStore } from './base.js';
+function cloneUser(user) {
+    return { ...user };
+}
+function normalizeUserId(identifier) {
+    if (typeof identifier === 'number' && Number.isFinite(identifier)) {
+        return identifier;
+    }
+    if (typeof identifier === 'string' && /^\d+$/.test(identifier)) {
+        return Number(identifier);
+    }
+    throw new Error(`Unable to normalise user identifier: ${identifier}`);
+}
+export class MemoryUserStore extends UserStore {
+    constructor(options = {}) {
+        super({
+            toPublic: options.toPublic,
+            bcryptRounds: options.bcryptRounds,
+            bcryptPepper: options.bcryptPepper
+        });
+        this.usersById = new Map();
+        this.loginToId = new Map();
+        this.emailToId = new Map();
+        this.nextUserId = Number.isFinite(options.startingUserId) ? Number(options.startingUserId) : 1;
+        this.userIdFactory =
+            options.userIdFactory ??
+                (() => {
+                    const id = this.nextUserId;
+                    this.nextUserId += 1;
+                    return id;
+                });
+    }
+    async findUser(identifier) {
+        if (typeof identifier === 'number') {
+            const user = this.usersById.get(identifier);
+            return user ? cloneUser(user) : null;
+        }
+        if (typeof identifier === 'string') {
+            const numeric = /^\d+$/.test(identifier) ? Number(identifier) : null;
+            if (numeric !== null) {
+                const user = this.usersById.get(numeric);
+                if (user) {
+                    return cloneUser(user);
+                }
+            }
+            const loginId = this.loginToId.get(identifier);
+            if (loginId !== undefined) {
+                return cloneUser(this.usersById.get(loginId));
+            }
+            const emailId = this.emailToId.get(identifier);
+            if (emailId !== undefined) {
+                return cloneUser(this.usersById.get(emailId));
+            }
+        }
+        return null;
+    }
+    async findById(id) {
+        try {
+            const numeric = normalizeUserId(id);
+            const user = this.usersById.get(numeric);
+            return user ? cloneUser(user) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async findByLoginOrEmail(loginOrEmail) {
+        return this.findUser(loginOrEmail);
+    }
+    async createUser(input) {
+        const normalizedInput = this.normalizeUserInput(input);
+        const providedId = input.user_id;
+        const userId = typeof providedId === 'number' && Number.isFinite(providedId) ? providedId : this.userIdFactory();
+        if (this.usersById.has(userId)) {
+            throw new Error(`User ${userId} already exists`);
+        }
+        if (this.loginToId.has(normalizedInput.login)) {
+            throw new Error(`User with login ${normalizedInput.login} already exists`);
+        }
+        if (this.emailToId.has(normalizedInput.email)) {
+            throw new Error(`User with email ${normalizedInput.email} already exists`);
+        }
+        const passwordHash = normalizedInput.password ? await this.hashPassword(normalizedInput.password) : '';
+        const record = {
+            ...normalizedInput,
+            user_id: userId,
+            password: passwordHash
+        };
+        this.persistUser(record);
+        if (typeof providedId === 'number' && Number.isFinite(providedId)) {
+            this.nextUserId = Math.max(this.nextUserId, providedId + 1);
+        }
+        return cloneUser(record);
+    }
+    async upsertUser(input) {
+        const normalizedInput = this.normalizeUserInput(input);
+        const providedId = input.user_id;
+        if (providedId !== undefined) {
+            const existing = this.usersById.get(providedId);
+            if (!existing) {
+                throw new Error(`User ${providedId} not found`);
+            }
+            const updates = {
+                ...existing,
+                ...normalizedInput
+            };
+            if (updates.login !== existing.login) {
+                const loginOwner = this.loginToId.get(updates.login);
+                if (loginOwner !== undefined && loginOwner !== existing.user_id) {
+                    throw new Error(`User with login ${updates.login} already exists`);
+                }
+            }
+            if (updates.email !== existing.email) {
+                const emailOwner = this.emailToId.get(updates.email);
+                if (emailOwner !== undefined && emailOwner !== existing.user_id) {
+                    throw new Error(`User with email ${updates.email} already exists`);
+                }
+            }
+            if (normalizedInput.password) {
+                updates.password = await this.hashPassword(normalizedInput.password);
+            }
+            this.persistUser(updates);
+            return cloneUser(updates);
+        }
+        return this.createUser(input);
+    }
+    async updateUser(id, patch) {
+        const user = await this.findById(id);
+        if (!user) {
+            throw new Error(`User ${String(id)} not found`);
+        }
+        const updates = { ...user, ...patch };
+        if (patch.password) {
+            updates.password = await this.hashPassword(patch.password);
+        }
+        this.persistUser(updates);
+        return cloneUser(updates);
+    }
+    async setPasswordHash(id, hash) {
+        const user = await this.findById(id);
+        if (!user) {
+            throw new Error(`User ${String(id)} not found`);
+        }
+        const updates = { ...user, password: hash };
+        this.persistUser(updates);
+    }
+    getPasswordHash(user) {
+        return user.password;
+    }
+    getUserId(user) {
+        return user.user_id;
+    }
+    persistUser(user) {
+        const snapshot = { ...user };
+        this.usersById.set(user.user_id, snapshot);
+        for (const [login, id] of [...this.loginToId.entries()]) {
+            if (id === user.user_id && login !== user.login) {
+                this.loginToId.delete(login);
+            }
+        }
+        for (const [email, id] of [...this.emailToId.entries()]) {
+            if (id === user.user_id && email !== user.email) {
+                this.emailToId.delete(email);
+            }
+        }
+        this.loginToId.set(user.login, user.user_id);
+        this.emailToId.set(user.email, user.user_id);
+    }
+}