polfan-server-js-client 0.0.6 → 0.0.8

package/build/types/index.d.ts

@@ -1,23 +1,9 @@
-import { Client } from "./Client";
+import { Client, ClientEvent } from "./Client";
 import { WebApiConnection } from "./connections/WebApiConnection";
-import { getToken } from "./Token";
 import { WebSocketConnection } from "./connections/WebSocketConnection";
+import { RestApiConnection } from "./connections/RestApiConnection";
+import { ChatConnectionEvent } from "./connections/ConnectionAssets";
+import { events, commands } from "./protocol";
 import { Dto } from "./dtos/Dto";
 import { Envelope } from "./dtos/protocol/Envelope";
-import { EnvelopeMeta } from "./dtos/protocol/EnvelopeMeta";
-declare const connections: {
-    WebApi: typeof WebApiConnection;
-    WebSocket: typeof WebSocketConnection;
-};
-declare const data: {
-    Dto: typeof Dto;
-    Envelope: typeof Envelope;
-    EnvelopeMeta: typeof EnvelopeMeta;
-    events: {
-        [x: string]: typeof Dto;
-    };
-    commands: {
-        [x: string]: typeof Dto;
-    };
-};
-export { Client, connections, data, getToken };
+export { Client, ClientEvent, WebSocketConnection, WebApiConnection, RestApiConnection, ChatConnectionEvent, Dto, Envelope, events, commands, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polfan-server-js-client",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "JavaScript client library for handling communication with Polfan chat server.",
   "author": "Jarosław Żak",
   "license": "MIT",

package/scripts/getPackageJson.js

@@ -0,0 +1,25 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * A module to get package informations from package.json
+ * @module getPackageJson
+ * @param {...string} keys from package.json if no arguments passed it returns package.json content as object
+ * @returns {object} with given keys or content of package.json as object
+ */
+
+/**
+ * Returns package info
+ */
+const getPackageJson = function(...args) {
+  const packageJSON = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json')));
+  if (!args.length) {
+    return packageJSON;
+  }
+  return args.reduce((out, key) => {
+    out[key] = packageJSON[key];
+    return out;
+  }, {});
+};
+
+module.exports = getPackageJson;

package/scripts/testMock.js

@@ -0,0 +1 @@
+module.exports = {};

package/src/Client.ts

@@ -0,0 +1,239 @@
+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',
+    renewal = 'renewalStart',
+    renewalSuccess = 'renewalSuccess',
+    renewalError = 'renewalError',
+}
+
+export interface TokenInterface {
+    token: string,
+    expiration: string
+}
+
+export interface MyAccountInterface {
+    id: number;
+    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};
+
+    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));
+    }
+
+    /**
+     * 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 destroy(): this {
+        this.chatConnection.destroy();
+        return this;
+    }
+
+    public async getMe(): Promise<MyAccountInterface> {
+        const response = await this.restConnection.send('GET', 'auth/me');
+        if (response.ok) {
+            return response.data;
+        }
+        throw new Error(`Cannot get current user account: ${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', message, dto);
+    }
+
+    private onDisconnect(reconnect: boolean): void {
+        this.awaitingResponse.forEach(([resolve, reject], key: string) => {
+            reject('Disconnected');
+            this.awaitingResponse.delete(key);
+        });
+        if (reconnect) {
+            this.emit(ClientEvent.renewal);
+            this.chatConnection.once(ChatConnectionEvent.ready, () => this.emit(ClientEvent.renewalSuccess));
+            this.chatConnection.once(ChatConnectionEvent.error, () => this.emit(ClientEvent.renewalError));
+        }
+    }
+
+    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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,19 @@
+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 {
+    send(data: any): void;
+    destroy(): void;
+}

package/src/connections/RestApiConnection.ts

@@ -0,0 +1,47 @@
+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/WebApiConnection.ts

@@ -0,0 +1,78 @@
+import {ChatConnectionInterface, ChatConnectionEvent, ConnectionOptionsInterface} from "./ConnectionAssets";
+import {EventTarget} from "../ObservableInterface";
+
+export interface WebApiConnectionOptionsInterface extends ConnectionOptionsInterface {
+    attemptsToSend?: number;
+    attemptDelayMs?: number;
+}
+
+export class WebApiConnection extends EventTarget implements ChatConnectionInterface {
+    protected sendStack: {data: any, attempts: number, lastTimeoutId: any}[];
+
+    public constructor(
+        protected readonly options: WebApiConnectionOptionsInterface
+    ) {
+        super();
+        if (!this.options.token && !this.options.temporaryNick) {
+            throw new Error('Token or temporary nick is required for authentication');
+        }
+    }
+
+    public send(data: any): void {
+        this.sendStack.push({data: data, attempts: 0, lastTimeoutId: null});
+        this.makeApiCall(this.sendStack.length - 1);
+    }
+
+    public destroy(): void {
+        // Cancel all awaiting requests
+        this.sendStack.forEach(item => {
+            if (item.lastTimeoutId) {
+                clearTimeout(item.lastTimeoutId);
+            }
+        });
+        this.sendStack = [];
+        this.emit(ChatConnectionEvent.destroy, false);
+    }
+
+    protected async onMessage(reqId: number, response: Response): Promise<void> {
+        this.sendStack.splice(reqId, 1);
+        this.emit(ChatConnectionEvent.message, await response.json());
+    }
+
+    protected onError(reqId: number, body: string): void {
+        if (this.sendStack[reqId].attempts >= (this.options.attemptsToSend ?? 10)) {
+            this.sendStack.splice(reqId, 1);
+            this.emit(ChatConnectionEvent.error, new Error(
+                `Cannot send ${body}; aborting after reaching the maximum connection errors`)
+            );
+            return;
+        }
+        this.sendStack[reqId].lastTimeoutId = setTimeout(
+            () => this.makeApiCall(reqId),
+            this.options.attemptDelayMs ?? 3000
+        );
+    }
+
+    protected makeApiCall(reqId: number): void {
+        this.sendStack[reqId].attempts++;
+        const bodyJson = JSON.stringify(this.sendStack[reqId].data);
+        const headers: any = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json'
+        };
+
+        if (this.options.token) {
+            headers.Authorization = `Bearer ${this.options.token}`;
+        } else if (this.options.temporaryNick) {
+            headers.Authorization = `Temp ${this.options.temporaryNick}`;
+        }
+
+        fetch(this.options.url, {
+            headers,
+            body: bodyJson,
+            method: 'POST',
+        })
+            .then(response => this.onMessage(reqId, response))
+            .catch(() => this.onError(reqId, bodyJson));
+    }
+}

package/src/connections/WebSocketConnection.ts

@@ -0,0 +1,95 @@
+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 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();
+    }
+
+    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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,12 @@
+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);
+    }
+}