polfan-server-js-client 0.0.96 → 0.1.1

package/src/Client.ts

@@ -1,267 +0,0 @@
-import {ChatConnectionEvent, ChatConnectionInterface} from "./connections/ConnectionAssets";
-import {EventTarget} from "./ObservableInterface";
-import {Envelope} from "./dtos/protocol/Envelope";
-import {JoinRoom} from "./dtos/protocol/commands/JoinRoom";
-import {Dto} from "./dtos/Dto";
-import {RoomJoined} from "./dtos/protocol/events/RoomJoined";
-import {LeaveRoom} from "./dtos/protocol/commands/LeaveRoom";
-import {RoomLeft} from "./dtos/protocol/events/RoomLeft";
-import {CreateRoom} from "./dtos/protocol/commands/CreateRoom";
-import {Error as ErrorEvent} from "./dtos/protocol/events/Error";
-import {SpaceRooms} from "./dtos/protocol/events/SpaceRooms";
-import {DeleteRoom} from "./dtos/protocol/commands/DeleteRoom";
-import {RoomDeleted} from "./dtos/protocol/events/RoomDeleted";
-import {GetRoomMembers} from "./dtos/protocol/commands/GetRoomMembers";
-import {RoomMembers} from "./dtos/protocol/events/RoomMembers";
-import {JoinSpace} from "./dtos/protocol/commands/JoinSpace";
-import {SpaceJoined} from "./dtos/protocol/events/SpaceJoined";
-import {LeaveSpace} from "./dtos/protocol/commands/LeaveSpace";
-import {SpaceLeft} from "./dtos/protocol/events/SpaceLeft";
-import {CreateSpace} from "./dtos/protocol/commands/CreateSpace";
-import {DeleteSpace} from "./dtos/protocol/commands/DeleteSpace";
-import {SpaceDeleted} from "./dtos/protocol/events/SpaceDeleted";
-import {GetSpaceMembers} from "./dtos/protocol/commands/GetSpaceMembers";
-import {SpaceMembers} from "./dtos/protocol/events/SpaceMembers";
-import {GetSpaceRooms} from "./dtos/protocol/commands/GetSpaceRooms";
-import {GetSession} from "./dtos/protocol/commands/GetSession";
-import {Session} from "./dtos/protocol/events/Session";
-import {AssignRole} from "./dtos/protocol/commands/AssignRole";
-import {SpaceMemberUpdate} from "./dtos/protocol/events/SpaceMemberUpdate";
-import {DeassignRole} from "./dtos/protocol/commands/DeassignRole";
-import {CreateRole} from "./dtos/protocol/commands/CreateRole";
-import {NewRole} from "./dtos/protocol/events/NewRole";
-import {DeleteRole} from "./dtos/protocol/commands/DeleteRole";
-import {RoleDeleted} from "./dtos/protocol/events/RoleDeleted";
-import {SetRolePermissions} from "./dtos/protocol/commands/SetRolePermissions";
-import {Permissions} from "./dtos/protocol/events/Permissions";
-import {SetUserPermissions} from "./dtos/protocol/commands/SetUserPermissions";
-import {CreateTopic} from "./dtos/protocol/commands/CreateTopic";
-import {NewTopic} from "./dtos/protocol/events/NewTopic";
-import {DeleteTopic} from "./dtos/protocol/commands/DeleteTopic";
-import {TopicDeleted} from "./dtos/protocol/events/TopicDeleted";
-import {CreateMessage} from "./dtos/protocol/commands/CreateMessage";
-import {NewMessage} from "./dtos/protocol/events/NewMessage";
-import {GetComputedPermissions} from "./dtos/protocol/commands/GetComputedPermissions";
-import {GetRolePermissions} from "./dtos/protocol/commands/GetRolePermissions";
-import {GetUserPermissions} from "./dtos/protocol/commands/GetUserPermissions";
-import {commands, events} from "./protocol";
-import {WebSocketConnection} from "./connections/WebSocketConnection";
-import {RestApiConnection} from "./connections/RestApiConnection";
-
-type ArrayOfPromiseResolvers = [(value: any) => void, (reason?: any) => void];
-type CmdResult<EventDto> = EventDto | ErrorEvent;
-type CommandsToEventsType<CommandT> =
-    // General commands
-    CommandT extends GetSession ? CmdResult<Session> :
-    CommandT extends SetUserPermissions ? CmdResult<Permissions> :
-    CommandT extends GetUserPermissions ? CmdResult<Permissions> :
-    CommandT extends GetComputedPermissions ? CmdResult<Permissions> :
-    // Space commands
-    CommandT extends JoinSpace ? CmdResult<SpaceJoined> :
-    CommandT extends LeaveSpace ? CmdResult<SpaceLeft> :
-    CommandT extends CreateSpace ? CmdResult<SpaceJoined> :
-    CommandT extends DeleteSpace ? CmdResult<SpaceDeleted> :
-    CommandT extends GetSpaceMembers ? CmdResult<SpaceMembers> :
-    CommandT extends GetSpaceRooms ? CmdResult<SpaceRooms> :
-    CommandT extends CreateRole ? CmdResult<NewRole> :
-    CommandT extends DeleteRole ? CmdResult<RoleDeleted> :
-    CommandT extends AssignRole ? CmdResult<SpaceMemberUpdate> :
-    CommandT extends DeassignRole ? CmdResult<SpaceMemberUpdate> :
-    CommandT extends SetRolePermissions ? CmdResult<Permissions> :
-    CommandT extends GetRolePermissions ? CmdResult<Permissions> :
-    // Room commands
-    CommandT extends JoinRoom ? CmdResult<RoomJoined> :
-    CommandT extends LeaveRoom ? CmdResult<RoomLeft> :
-    CommandT extends CreateRoom ? CmdResult<RoomJoined> :
-    CommandT extends DeleteRoom ? CmdResult<RoomDeleted> :
-    CommandT extends GetRoomMembers ? CmdResult<RoomMembers> :
-    // Topic commands
-    CommandT extends CreateTopic ? CmdResult<NewTopic> :
-    CommandT extends DeleteTopic ? CmdResult<TopicDeleted> :
-    CommandT extends CreateMessage ? CmdResult<NewMessage> :
-    any;
-
-function guessCommandType(obj: any): string {
-    for (const type in commands) {
-        if (obj instanceof commands[type]) {
-            return type;
-        }
-    }
-    return Object.getPrototypeOf(obj).constructor.name;
-}
-
-export enum ClientEvent {
-    message = 'message',
-    ready = 'ready',
-    renewal = 'renewalStart',
-    renewalSuccess = 'renewalSuccess',
-    renewalError = 'renewalError',
-}
-
-export interface TokenInterface {
-    token: string,
-    expiration: string
-}
-
-export interface MyAccountInterface {
-    id: string;
-    nick: string;
-    avatar: string;
-}
-
-export class Client extends EventTarget {
-    public static readonly defaultClientName = 'polfan-server-js-client';
-    public static readonly defaultWebSocketUrl = 'ws://pserv.shado.p5.tiktalik.io:1600/ws';
-    public static readonly defaultWebApiUrl = 'http://pserv.shado.p5.tiktalik.io:1600/api';
-    public static readonly defaultRestApiUrl = 'https://polfan.pl/webservice/api';
-    public static readonly defaultAvatarUrlPrefix = 'https://polfan.pl/modules/users/avatars/';
-
-    public static async getToken(
-        login: string,
-        password: string,
-        clientName: string = Client.defaultClientName
-    ): Promise<TokenInterface> {
-        const connection = new RestApiConnection({url: Client.defaultRestApiUrl});
-        const response = await connection.send('POST', 'auth/tokens', {
-            login, password, client_name: clientName
-        });
-        if (response.ok) {
-            return response.data;
-        }
-        throw new Error(`Cannot create user token: ${response.data.errors[0]}`);
-    }
-
-    public static createByToken(token: string): Client {
-        return new Client(
-            new WebSocketConnection({token, url: Client.defaultWebSocketUrl}),
-            new RestApiConnection({token, url: Client.defaultRestApiUrl}),
-        );
-    }
-
-    public static createByTemporaryNick(temporaryNick: string): Client {
-        return new Client(
-            new WebSocketConnection({temporaryNick, url: Client.defaultWebSocketUrl}),
-            new RestApiConnection({url: Client.defaultRestApiUrl}),
-        );
-    }
-
-    protected commandsCount = 0;
-    protected awaitingResponse: Map<string, ArrayOfPromiseResolvers> = new Map<string, ArrayOfPromiseResolvers>();
-    protected eventsMap: {[x: string]: typeof Dto};
-    protected reconnecting: boolean;
-
-    public constructor(
-        public readonly chatConnection: ChatConnectionInterface,
-        public readonly restConnection: RestApiConnection,
-    ) {
-        super();
-        this.setCustomEventMap({}); // Set default event map.
-        this.chatConnection.on(ChatConnectionEvent.message, (payload: any) => this.onMessage(payload));
-        this.chatConnection.on(ChatConnectionEvent.destroy, (reconnect: boolean) => this.onDisconnect(reconnect));
-        this.chatConnection.on(ChatConnectionEvent.ready, () => {
-            if (this.reconnecting) {
-                this.reconnecting = false;
-                this.emit(ClientEvent.renewalSuccess);
-                return;
-            }
-            this.emit(ClientEvent.ready);
-        });
-        this.chatConnection.on(ChatConnectionEvent.error, () => {
-            if (this.reconnecting) {
-                this.reconnecting = false;
-                this.emit(ClientEvent.renewalError);
-            }
-        });
-    }
-
-    /**
-     * Send command to chat server.
-     * @param commandPayload Command payload object.
-     * @param commandType Command type; if not specified, it will be guessed from the command payload class name.
-     * @return Promise which resolves to the event returned by server (including `Error`)
-     * in response to command and rejects with connection error.
-     */
-    public async sendCommand<CommandT extends Dto = any>(
-        commandPayload: CommandT,
-        commandType?: string
-    ): Promise<CommandsToEventsType<CommandT>> {
-        const message = this.createEnvelope(commandType ?? guessCommandType(commandPayload), commandPayload);
-        this.chatConnection.send(message.toRaw());
-        return new Promise(
-            (...args) => this.awaitingResponse.set(message.ref as string, args)
-        );
-    }
-
-    /**
-     * Set custom DTO classes for events.
-     */
-    public setCustomEventMap(customMap: {[x: string]: typeof Dto}): this {
-        this.eventsMap = {...events, ...customMap};
-        return this;
-    }
-
-    public init(): this {
-        this.chatConnection.init();
-        return this;
-    }
-
-    public destroy(): this {
-        this.chatConnection.destroy();
-        return this;
-    }
-
-    public async getMe(): Promise<MyAccountInterface> {
-        const response = await this.restConnection.send('GET', 'auth/me');
-        if (response.ok) {
-            response.data.id = response.data.id.toString();
-            return response.data;
-        }
-        throw new Error(`Cannot get current user account: ${response.data.errors[0]}`);
-    }
-
-    public async deleteToken(token: string): Promise<void> {
-        const response = await this.restConnection.send('DELETE', `auth/tokens/${token}`);
-        if (!response.ok) {
-            throw new Error(`Cannot delete access token: ${response.data.errors[0]}`);
-        }
-    }
-
-    private onMessage(message: any) {
-        const dto = this.createEvent(message);
-
-        const [resolve] = this.awaitingResponse.get(message.ref ?? '') ?? [];
-        if (resolve) {
-            resolve(dto ?? message.data);
-            this.awaitingResponse.delete(message.ref as string);
-        }
-
-        this.emit(ClientEvent.message, message);
-        this.emit(message.type ?? 'unknown', dto, message);
-    }
-
-    private onDisconnect(reconnect: boolean): void {
-        this.awaitingResponse.forEach(([resolve, reject], key: string) => {
-            reject('Disconnected');
-            this.awaitingResponse.delete(key);
-        });
-        if (reconnect) {
-            this.reconnecting = true;
-            this.emit(ClientEvent.renewal);
-        }
-    }
-
-    private createEnvelope(commandType: string, dto: Dto): Envelope {
-        return new Envelope({
-            type: commandType,
-            ref: (++this.commandsCount).toString(),
-            data: dto
-        });
-    }
-
-    private createEvent(message: Envelope): Dto | null {
-        if ((message.type ?? false) && this.eventsMap.hasOwnProperty(message.type)) {
-            return new (this.eventsMap[message.type] as any)(message.data);
-        }
-        return null;
-    }
-}

package/src/ObservableInterface.ts

@@ -1,39 +0,0 @@
-export type EventHandler<T = any> = (...args: T[]) => void;
-type HandlersMap = Map<string, EventHandler[]>;
-
-export interface ObservableInterface {
-    on(eventName: string, handler: EventHandler): ObservableInterface;
-    once(eventName: string, handler: EventHandler): ObservableInterface;
-}
-
-export abstract class EventTarget implements ObservableInterface {
-    protected events: HandlersMap = new Map<string, EventHandler[]>();
-    protected onceEvents: HandlersMap = new Map<string, EventHandler[]>();
-
-    public on(eventName: string, handler: EventHandler): EventTarget {
-        this.addHandler(this.events, eventName, handler);
-        return this;
-    }
-
-    public once(eventName: string, handler: EventHandler): EventTarget {
-        this.addHandler(this.onceEvents, eventName, handler);
-        return this;
-    }
-
-    public emit(eventName: string, ...args: any): EventTarget {
-        this.callHandlers(this.events, eventName, args);
-        this.callHandlers(this.onceEvents, eventName, args);
-        this.onceEvents.delete(eventName);
-        return this;
-    }
-
-    private addHandler(map: HandlersMap, eventName: string, handler: EventHandler): void {
-        const handlers = map.get(eventName) ?? [];
-        handlers.push(handler);
-        map.set(eventName, handlers);
-    }
-
-    private callHandlers(map: HandlersMap, eventName: string, args: any[]): void {
-        map.get(eventName)?.forEach(callback => callback(...args));
-    }
-}

package/src/connections/ConnectionAssets.ts

@@ -1,20 +0,0 @@
-import {ObservableInterface} from "../ObservableInterface";
-
-export enum ChatConnectionEvent {
-    message = 'message',
-    destroy = 'destroy',
-    ready = 'ready',
-    error = 'error',
-}
-
-export interface ConnectionOptionsInterface {
-    url: string;
-    token?: string;
-    temporaryNick?: string;
-}
-
-export interface ChatConnectionInterface extends ObservableInterface {
-    init(): void;
-    send(data: any): void;
-    destroy(): void;
-}

package/src/connections/RestApiConnection.ts

@@ -1,47 +0,0 @@
-import {ConnectionOptionsInterface} from "./ConnectionAssets";
-
-export interface RestResponseInterface {
-    ok: boolean;
-    status: number;
-    data: any;
-}
-
-export class RestApiConnection {
-    public constructor(protected options: ConnectionOptionsInterface) {
-        if (this.options.temporaryNick) {
-            throw new Error('Temporary nick is not supported authentication method for REST API');
-        }
-    }
-
-    public async send(method: string, uri: string, data: any = undefined): Promise<RestResponseInterface> {
-        const headers: any = {
-            'Content-Type': 'application/json',
-            Accept: 'application/json'
-        };
-
-        if (this.options.token) {
-            headers.Authorization = `Bearer ${this.options.token}`;
-        }
-
-        const body = data === undefined ? undefined : JSON.stringify(data);
-        const result = await fetch(this.getUrl(uri), {method, body, headers});
-
-        return {
-            ok: result.ok,
-            status: result.status,
-            data: await result.json(),
-        };
-    }
-
-    protected getUrl(uri: string): string {
-        return this.removeEndingSlash(this.options.url) + '/' + this.removeStartingSlash(uri);
-    }
-
-    private removeStartingSlash(text: string): string {
-        return text.replace(/^\/+/, '');
-    }
-
-    private removeEndingSlash(text: string): string {
-        return text.replace(/\/+$/, '');
-    }
-}

package/src/connections/WebSocketConnection.ts

@@ -1,103 +0,0 @@
-import {EventTarget} from "../ObservableInterface";
-import {
-    ChatConnectionEvent,
-    ChatConnectionInterface,
-    ConnectionOptionsInterface,
-} from "./ConnectionAssets";
-
-export interface WebSocketConnectionInterface extends ConnectionOptionsInterface {
-    awaitQueueSendDelayMs?: number;
-    connectingTimeoutMs?: number;
-}
-
-export class WebSocketConnection extends EventTarget implements ChatConnectionInterface {
-    protected ws: WebSocket|null = null;
-    protected sendQueue: any[] = [];
-    protected connectingTimeoutId: any;
-    protected authenticated: boolean;
-
-    public constructor(private readonly options: WebSocketConnectionInterface) {
-        super();
-        if (!this.options.token && !this.options.temporaryNick) {
-            throw new Error('Token or temporary nick is required');
-        }
-    }
-
-    public init() {
-        if (this.ws) {
-            this.destroy();
-        }
-        this.connect();
-    }
-
-    public send(data: any): void {
-        if (!this.ws || this.ws.readyState === this.ws.CLOSED) {
-            this.connect();
-        }
-        if (this.ws.readyState === this.ws.CONNECTING || !this.authenticated) {
-            this.sendQueue.push(data);
-            return;
-        }
-        const dataJson = JSON.stringify(data);
-        if (this.ws.readyState !== this.ws.OPEN) {
-            this.emit(ChatConnectionEvent.error, new Error(`Cannot send ${dataJson}; invalid connection state`));
-            return;
-        }
-        this.ws.send(dataJson);
-    }
-
-    public destroy(): void {
-        this.sendQueue = [];
-        this.ws?.close();
-        this.ws = null;
-    }
-
-    private connect(): void {
-        this.authenticated = false;
-        const authString = this.options.token ? `token=${this.options.token}` : `nick=${this.options.temporaryNick}`;
-        this.ws = new WebSocket(`${this.options.url}?${authString}`);
-        this.ws.onclose = ev => this.onClose(ev);
-        this.ws.onmessage = ev => this.onMessage(ev);
-        this.connectingTimeoutId = setTimeout(
-            () => this.triggerConnectionTimeout(),
-            this.options.connectingTimeoutMs ?? 10000
-        );
-    }
-
-    private onMessage(event: MessageEvent): void {
-        const payload = JSON.parse(event.data);
-        // Login successfully
-        if (!this.authenticated && payload.type && payload.type !== 'Error') {
-            this.authenticated = true;
-            this.emit(ChatConnectionEvent.ready);
-            this.sendFromQueue();
-        }
-        this.emit(ChatConnectionEvent.message, payload);
-    }
-
-    private onClose(event: CloseEvent): void {
-        clearTimeout(this.connectingTimeoutId);
-        const reconnect = event.code !== 1000; // Connection was closed because of error
-        if (reconnect) {
-            this.connect();
-        }
-        this.emit(ChatConnectionEvent.destroy, reconnect);
-    }
-
-    private sendFromQueue(): void {
-        // Send awaiting data to server
-        let lastDelay = 0;
-        for (const dataIndex in this.sendQueue) {
-            const data = this.sendQueue[dataIndex];
-            setTimeout(() => this.send(data), lastDelay);
-            lastDelay += this.options.awaitQueueSendDelayMs ?? 500;
-        }
-        this.sendQueue = [];
-        clearTimeout(this.connectingTimeoutId);
-    }
-
-    private triggerConnectionTimeout(): void {
-        this.destroy();
-        this.emit(ChatConnectionEvent.error, new Error('Connection timeout'));
-    }
-}

package/src/dtos/Dto.ts

@@ -1,45 +0,0 @@
-export function cast<T extends typeof Dto>(data: any, dto: T): T|undefined {
-    if (data instanceof dto) {
-        return data as any;
-    }
-    return new (dto as any)(data);
-}
-
-export function castArray<T extends typeof Dto>(data: any[], dto: T): T[] {
-    if (!Array.isArray(data)) throw new Error(`Passed data is not an array of ${dto.name}`);
-    return data.map(item => cast(item, dto));
-}
-
-type ExcludeMethods<T> = Pick<T, { [K in keyof T]: T[K] extends Function ? never : K }[keyof T]>;
-export type DtoData<T> = { [K in keyof ExcludeMethods<T>]: any };
-
-export abstract class Dto {
-    public constructor(...args: any[]) {
-    }
-
-    public toJson(overrideBy: any = {}): string {
-        return JSON.stringify(this.toRaw(overrideBy));
-    }
-
-    public toRaw(overrideBy: any = {}): DtoData<this> {
-        const object: {[key: string]: any} = {};
-        Object.keys(this).forEach(key => {
-            if (overrideBy.hasOwnProperty(key)) {
-                object[key] = overrideBy[key];
-            } else if ((this as any)[key] instanceof Dto) {
-                object[key] = (this as any)[key].toRaw();
-            } else {
-                object[key] = (this as any)[key]
-            }
-        });
-        return object as DtoData<this>;
-    }
-
-    public clone(overrideBy: any = {}): this {
-        return new (this.constructor as any)(this.toRaw(overrideBy));
-    }
-
-    protected fill(data: any, overrideBy: any = {}) {
-        Object.assign(this, {...data, ...overrideBy});
-    }
-}

package/src/dtos/Message.ts

@@ -1,16 +0,0 @@
-import {cast, Dto, DtoData} from "./Dto";
-import {User} from "./User";
-
-export class Message extends Dto {
-    public readonly id: string;
-    public readonly author: User;
-    public readonly topicId: string;
-    public readonly content: string;
-
-    public constructor(data: DtoData<Message>) {
-        super();
-        this.fill(data, {
-            author: cast(data.author, User),
-        });
-    }
-}

package/src/dtos/Permission.ts

@@ -1,12 +0,0 @@
-import {Dto, DtoData} from "./Dto";
-
-export class Permission extends Dto {
-    public readonly name: string;
-    public readonly value: boolean;
-    public readonly skip: boolean;
-
-    public constructor(data: DtoData<Permission>) {
-        super(data);
-        this.fill(data);
-    }
-}

package/src/dtos/Role.ts

@@ -1,12 +0,0 @@
-import {Dto, DtoData} from "./Dto";
-
-export class Role extends Dto {
-    public readonly id: string;
-    public readonly name: string;
-    public readonly color?: string;
-
-    public constructor(data: DtoData<Role>) {
-        super();
-        this.fill(data);
-    }
-}

package/src/dtos/Room.ts

@@ -1,17 +0,0 @@
-import {castArray, Dto, DtoData} from "./Dto";
-import {Topic} from "./Topic";
-
-export class Room extends Dto {
-    public readonly id: string;
-    public readonly spaceId: string|null;
-    public readonly name: string;
-    public readonly description: string;
-    public readonly topics: Topic[];
-
-    public constructor(data: DtoData<Room>) {
-        super();
-        this.fill(data, {
-            topics: castArray(data.topics, Topic),
-        });
-    }
-}

package/src/dtos/RoomMember.ts

@@ -1,13 +0,0 @@
-import {cast, Dto, DtoData} from "./Dto";
-import {User} from "./User";
-
-export class RoomMember extends Dto {
-    public readonly user: User;
-
-    public constructor(data: DtoData<RoomMember>) {
-        super();
-        this.fill(data, {
-            user: cast(data.user, User),
-        });
-    }
-}

package/src/dtos/RoomSummary.ts

@@ -1,12 +0,0 @@
-import {Dto, DtoData} from "./Dto";
-
-export class RoomSummary extends Dto {
-    public readonly id: string;
-    public readonly name: string;
-    public readonly description: string;
-
-    public constructor(data: DtoData<RoomSummary>) {
-        super();
-        this.fill(data);
-    }
-}

package/src/dtos/Space.ts

@@ -1,15 +0,0 @@
-import {castArray, Dto, DtoData} from "./Dto";
-import {Role} from "./Role";
-
-export class Space extends Dto {
-    public readonly id: string;
-    public readonly name: string;
-    public readonly roles: Role[];
-
-    public constructor(data: DtoData<Space>) {
-        super();
-        this.fill(data, {
-            roles: castArray(data.roles, Role)
-        });
-    }
-}

package/src/dtos/SpaceMember.ts

@@ -1,14 +0,0 @@
-import {castArray, Dto, DtoData} from "./Dto";
-import {User} from "./User";
-
-export class SpaceMember extends Dto {
-    public readonly user: User;
-    public readonly roles: string[];
-
-    public constructor(data: DtoData<SpaceMember>) {
-        super();
-        this.fill(data, {
-            user: castArray(data.user, User),
-        });
-    }
-}

package/src/dtos/Topic.ts

@@ -1,12 +0,0 @@
-import {Dto, DtoData} from "./Dto";
-
-export class Topic extends Dto {
-    public readonly id: string;
-    public readonly name: string;
-    public readonly description: string;
-
-    public constructor(data: DtoData<Topic>) {
-        super();
-        this.fill(data);
-    }
-}

package/src/dtos/User.ts

@@ -1,15 +0,0 @@
-import {Dto, DtoData} from "./Dto";
-
-export type UserFlag = 'bot' | 'temp';
-
-export class User extends Dto {
-    public readonly id: string;
-    public readonly nick: string;
-    public readonly avatar: string;
-    public readonly flags: UserFlag[];
-
-    public constructor(data: DtoData<User>) {
-        super();
-        this.fill(data);
-    }
-}