@basmilius/http-client 1.13.0 → 2.1.0

package/src/decorator/dto/serialize/deserializeArray.ts

@@ -0,0 +1,5 @@
+import deserializeUnknown from './deserializeUnknown';
+
+export default function (obj: unknown[]): unknown[] {
+    return obj.map(deserializeUnknown);
+}

package/src/decorator/dto/serialize/deserializeDateTime.ts

@@ -0,0 +1,6 @@
+import { DateTime } from 'luxon';
+import type { SerializedDateTime } from './types';
+
+export default function ([, iso]: SerializedDateTime): DateTime {
+    return DateTime.fromISO(iso);
+}

package/src/decorator/dto/serialize/deserializeDto.ts

@@ -0,0 +1,28 @@
+import { ENABLE_SERIALIZATION_LOGGING } from '../constant';
+import { DTO_CLASS_MAP } from '../map';
+import type { SerializedDto } from './types';
+import type DtoInstance from '../instance';
+import deserializeArray from './deserializeArray';
+import deserializeObject from './deserializeObject';
+
+const CACHE: Record<string, unknown> = {};
+
+export default function ([, id, name, state, args]: SerializedDto): DtoInstance<unknown> {
+    if (!(name in DTO_CLASS_MAP)) {
+        throw new Error(`Cannot restore @dto. Dto ${name} was not found.`);
+    }
+
+    if (id in CACHE) {
+        return CACHE[id] as DtoInstance<unknown>;
+    }
+
+    ENABLE_SERIALIZATION_LOGGING && console.group('⭐️', name, id);
+    const Dto = DTO_CLASS_MAP[name];
+    const instance = new Dto(...deserializeArray(args));
+    instance.fill(deserializeObject(state));
+    ENABLE_SERIALIZATION_LOGGING && console.groupEnd();
+
+    CACHE[id] = instance;
+
+    return instance;
+}

package/src/decorator/dto/serialize/deserializeObject.ts

@@ -0,0 +1,9 @@
+import deserializeUnknown from './deserializeUnknown';
+
+export default function (obj: object): Record<string, unknown> {
+    return Object.fromEntries(
+        Object.entries(obj)
+            .map(([key, value]) => [key, deserializeUnknown(value)])
+            .filter(([, value]) => value !== undefined)
+    );
+}

package/src/decorator/dto/serialize/deserializeUnknown.ts

@@ -0,0 +1,31 @@
+import deserializeArray from './deserializeArray';
+import deserializeDateTime from './deserializeDateTime';
+import deserializeDto from './deserializeDto';
+import deserializeObject from './deserializeObject';
+import isSerializedDateTime from './isSerializedDateTime';
+import isSerializedDto from './isSerializedDto';
+
+export default function (obj: unknown): unknown {
+    switch (true) {
+        case obj === null:
+            return null;
+
+        case Array.isArray(obj):
+            switch (true) {
+                case isSerializedDateTime(obj):
+                    return deserializeDateTime(obj);
+
+                case isSerializedDto(obj):
+                    return deserializeDto(obj);
+
+                default:
+                    return deserializeArray(obj);
+            }
+
+        case typeof obj === 'object':
+            return deserializeObject(obj);
+
+        default:
+            return obj;
+    }
+}

package/src/decorator/dto/serialize/index.ts

@@ -0,0 +1,7 @@
+import deserialize from './deserialize';
+import serialize from './serialize';
+
+export {
+    deserialize,
+    serialize
+};

package/src/decorator/dto/serialize/isSerializedDateTime.ts

@@ -0,0 +1,5 @@
+import type { SerializedDateTime } from './types';
+
+export default function (obj: unknown): obj is SerializedDateTime {
+    return Array.isArray(obj) && obj[0] === 0xBF2;
+}

package/src/decorator/dto/serialize/isSerializedDto.ts

@@ -0,0 +1,5 @@
+import type { SerializedDto } from './types';
+
+export default function (obj: unknown): obj is SerializedDto {
+    return Array.isArray(obj) && obj[0] === 0xBF1;
+}

package/src/decorator/dto/serialize/serialize.ts

@@ -0,0 +1,5 @@
+import serializeUnknown from './serializeUnknown';
+
+export default function (obj: unknown): string {
+    return JSON.stringify(serializeUnknown(obj));
+}

package/src/decorator/dto/serialize/serializeArray.ts

@@ -0,0 +1,19 @@
+import { DateTime } from 'luxon';
+import type { Serialized } from './types';
+import isDto from '../helper/isDto';
+import serializeDateTime from './serializeDateTime';
+import serializeDto from './serializeDto';
+import serializeUnknown from './serializeUnknown';
+
+export default function (obj: unknown[]): Serialized[] {
+    switch (true) {
+        case obj.every(isDto):
+            return obj.map(serializeDto);
+
+        case obj.every(DateTime.isDateTime):
+            return obj.map(serializeDateTime);
+
+        default:
+            return obj.map(serializeUnknown);
+    }
+}

package/src/decorator/dto/serialize/serializeDateTime.ts

@@ -0,0 +1,9 @@
+import type { DateTime } from 'luxon';
+import type { SerializedDateTime } from './types';
+
+export default function (obj: DateTime): SerializedDateTime {
+    return [0xBF2, obj.toISO({
+        extendedZone: true,
+        includeOffset: true
+    })];
+}

package/src/decorator/dto/serialize/serializeDto.ts

@@ -0,0 +1,21 @@
+import { toRaw } from 'vue';
+import { ARGS, NAME } from '../symbols';
+import type { SerializedDto } from './types';
+import type DtoInstance from '../instance';
+import serializeArray from './serializeArray';
+import serializeObject from './serializeObject';
+import uuid from './uuid';
+
+export default function (obj: DtoInstance<unknown>): SerializedDto {
+    obj = toRaw(obj);
+
+    const json = obj.toJSON();
+
+    return [
+        0xBF1,
+        uuid(),
+        obj[NAME],
+        serializeObject(json),
+        serializeArray(obj[ARGS])
+    ];
+}

package/src/decorator/dto/serialize/serializeObject.ts

@@ -0,0 +1,9 @@
+import serializeUnknown from './serializeUnknown';
+
+export default function (obj: object): Record<string, unknown> {
+    return Object.fromEntries(
+        Object.entries(obj)
+            .map(([key, value]) => [key, serializeUnknown(value)])
+            .filter(([, value]) => value !== undefined)
+    );
+}

package/src/decorator/dto/serialize/serializeUnknown.ts

@@ -0,0 +1,34 @@
+import { DateTime } from 'luxon';
+import type { Serialized } from './types';
+import isDto from '../helper/isDto';
+import serializeArray from './serializeArray';
+import serializeDateTime from './serializeDateTime';
+import serializeDto from './serializeDto';
+import serializeObject from './serializeObject';
+
+export default function (obj: unknown): Serialized | undefined {
+    switch (true) {
+        case obj === null:
+            return null;
+
+        case Array.isArray(obj):
+            return serializeArray(obj);
+
+        case isDto(obj):
+            return serializeDto(obj);
+
+        case DateTime.isDateTime(obj):
+            return serializeDateTime(obj);
+
+        case typeof obj === 'object':
+            return serializeObject(obj);
+
+        case typeof obj === 'boolean':
+        case typeof obj === 'number':
+        case typeof obj === 'string':
+            return obj;
+
+        default:
+            return undefined;
+    }
+}

package/src/decorator/dto/serialize/types.ts

@@ -0,0 +1,3 @@
+export type SerializedDateTime = [0xBF2, string];
+export type SerializedDto = [0xBF1, string, string, Record<string, unknown>, any[]];
+export type Serialized = boolean | number | string | Record<string, unknown> | SerializedDateTime | SerializedDto | Serialized[];

package/src/decorator/dto/serialize/uuid.ts

@@ -0,0 +1,3 @@
+export default function () {
+    return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, c => (+c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16));
+}

package/src/decorator/dto/symbols.ts

@@ -0,0 +1,11 @@
+export const ARGS: unique symbol = Symbol();
+export const CHILDREN: unique symbol = Symbol();
+export const DESCRIPTORS: unique symbol = Symbol();
+export const DIRTY: unique symbol = Symbol();
+export const NAME: unique symbol = Symbol();
+export const PARENT: unique symbol = Symbol();
+export const PARENT_KEY: unique symbol = Symbol();
+export const PROPERTIES: unique symbol = Symbol();
+export const PROXY: unique symbol = Symbol();
+export const TRACK: unique symbol = Symbol();
+export const TRIGGER: unique symbol = Symbol();

package/src/decorator/dto/toJSON.ts

@@ -0,0 +1,20 @@
+import { isDto } from './helper';
+import { PROPERTIES } from './symbols';
+import type DtoInstance from './instance';
+
+/**
+ * Returns the json object representation of the dto.
+ */
+export default function (this: DtoInstance<unknown>): Record<string, unknown> {
+    return Object.fromEntries(
+        this[PROPERTIES].map(property => {
+            let value: unknown = Reflect.get.call(this, this, property, this);
+
+            if (isDto(value)) {
+                value = value.toJSON();
+            }
+
+            return [property, value];
+        })
+    );
+}

package/src/decorator/index.ts

@@ -0,0 +1,31 @@
+import adapter from './adapter';
+import bound from './bound';
+import debounce from './debounce';
+import dto from './dto';
+
+export {
+    adapter,
+    bound,
+    debounce,
+    dto
+};
+
+export {
+    assertDto,
+    cloneDto,
+    executeIfDtoDirtyAndMarkClean,
+    isDto,
+    isDtoClean,
+    isDtoDirty,
+    markDtoClean,
+    markDtoDirty
+} from './dto/helper';
+
+export {
+    deserialize,
+    serialize
+} from './dto/serialize';
+
+export type {
+    DtoInstance
+} from './dto';

package/src/dto/BlobResponse.ts

@@ -0,0 +1,20 @@
+import { dto } from '../decorator';
+
+@dto
+export default class BlobResponse {
+    get blob(): Blob {
+        return this.#blob;
+    }
+
+    get name(): string {
+        return this.#name;
+    }
+
+    readonly #blob: Blob;
+    readonly #name: string;
+
+    constructor(blob: Blob, name: string) {
+        this.#blob = blob;
+        this.#name = name;
+    }
+}

package/src/dto/Paginated.ts

@@ -0,0 +1,38 @@
+import { dto } from '../decorator';
+
+@dto
+export default class Paginated<T> {
+    get items(): T[] {
+        return this.#items;
+    }
+
+    get page(): number {
+        return this.#page;
+    }
+
+    get pageSize(): number {
+        return this.#pageSize;
+    }
+
+    get pages(): number {
+        return this.#pages;
+    }
+
+    get totalItems(): number {
+        return this.#totalItems;
+    }
+
+    readonly #items: T[];
+    readonly #page: number;
+    readonly #pageSize: number;
+    readonly #pages: number;
+    readonly #totalItems: number;
+
+    constructor(items: T[], page: number, pageSize: number, pages: number, totalItems: number) {
+        this.#items = items;
+        this.#page = page;
+        this.#pageSize = pageSize;
+        this.#pages = pages;
+        this.#totalItems = totalItems;
+    }
+}

package/src/dto/RequestError.ts

@@ -0,0 +1,33 @@
+import { dto } from '../decorator';
+import type { HttpStatusCode } from '../type';
+
+@dto
+export default class RequestError {
+    get code(): number {
+        return this.#code;
+    }
+
+    get error(): string {
+        return this.#error;
+    }
+
+    get errorDescription(): string {
+        return this.#errorDescription;
+    }
+
+    get statusCode(): HttpStatusCode {
+        return this.#statusCode;
+    }
+
+    readonly #code: number;
+    readonly #error: string;
+    readonly #errorDescription: string;
+    readonly #statusCode: HttpStatusCode;
+
+    constructor(code: number, error: string, errorDescription: string, statusCode: HttpStatusCode) {
+        this.#code = code;
+        this.#error = error;
+        this.#errorDescription = errorDescription;
+        this.#statusCode = statusCode;
+    }
+}

package/src/dto/ValidationError.ts

@@ -0,0 +1,38 @@
+import { dto } from '../decorator';
+
+@dto
+export default class ValidationError {
+    get code(): number {
+        return this.#code;
+    }
+
+    get error(): string {
+        return this.#error;
+    }
+
+    get errorDescription(): string {
+        return this.#errorDescription;
+    }
+
+    get errors(): Record<string, ValidationError> {
+        return this.#errors;
+    }
+
+    get params(): Record<string, string | number | boolean> {
+        return this.#params;
+    }
+
+    readonly #code: number;
+    readonly #error: string;
+    readonly #errorDescription: string;
+    readonly #errors: Record<string, ValidationError>;
+    readonly #params: Record<string, string | number | boolean>;
+
+    constructor(code: number, error: string, errorDescription: string, errors?: Record<string, ValidationError>, params?: Record<string, string | number | boolean>) {
+        this.#code = code;
+        this.#error = error;
+        this.#errorDescription = errorDescription;
+        this.#errors = errors;
+        this.#params = params;
+    }
+}

package/src/dto/index.ts

@@ -0,0 +1,4 @@
+export { default as BlobResponse } from './BlobResponse';
+export { default as Paginated } from './Paginated';
+export { default as RequestError } from './RequestError';
+export { default as ValidationError } from './ValidationError';

package/src/http/BaseResponse.ts

@@ -0,0 +1,31 @@
+import type { HttpStatusCode } from '../type';
+
+export default class BaseResponse<T> {
+    get data(): T {
+        return this.#data;
+    }
+
+    get headers(): Headers {
+        return this.#response.headers;
+    }
+
+    get ok(): boolean {
+        return this.statusCode >= 200 && this.statusCode < 300;
+    }
+
+    get response(): Response {
+        return this.#response;
+    }
+
+    get statusCode(): HttpStatusCode {
+        return this.#response.status as HttpStatusCode;
+    }
+
+    readonly #data: T;
+    readonly #response: Response;
+
+    constructor(data: T, response: Response) {
+        this.#data = data;
+        this.#response = response;
+    }
+}

package/src/http/BaseService.ts

@@ -0,0 +1,8 @@
+import HttpClient from './HttpClient';
+import RequestBuilder from './RequestBuilder';
+
+export default class BaseService {
+    protected request(path: string, client?: HttpClient): RequestBuilder {
+        return new RequestBuilder(path, client);
+    }
+}

package/src/http/HttpClient.ts

@@ -0,0 +1,41 @@
+export default class HttpClient {
+    get authToken(): string | null {
+        return this.#authToken;
+    }
+
+    set authToken(value: string | null) {
+        this.#authToken = value;
+    }
+
+    get baseUrl(): string {
+        return this.#baseUrl;
+    }
+
+    get dataField(): boolean {
+        return this.#dataField;
+    }
+
+    #authToken: string | null;
+    readonly #baseUrl: string;
+    readonly #dataField: boolean;
+
+    constructor(authToken: string | null, baseUrl: string, dataField: boolean = false) {
+        this.#authToken = authToken;
+        this.#baseUrl = baseUrl;
+        this.#dataField = dataField;
+    }
+
+    static get instance(): HttpClient {
+        if (HttpClient.#instance === null) {
+            throw new Error('There is currently no HttpClient instance registered. Register one using the HttpClient.register() function.');
+        }
+
+        return HttpClient.#instance;
+    }
+
+    static #instance: HttpClient | null = null;
+
+    static register(client: HttpClient): void {
+        HttpClient.#instance = client;
+    }
+}

package/src/http/QueryString.ts

@@ -0,0 +1,75 @@
+export default class QueryString {
+    readonly #builder: URLSearchParams;
+
+    constructor() {
+        this.#builder = new URLSearchParams();
+    }
+
+    public build(): string {
+        return this.#builder.toString();
+    }
+
+    public append(name: string, value: QueryStringValue): QueryString {
+        return this.#add(this.#builder.append.bind(this.#builder), name, value);
+    }
+
+    public appendArray(name: string, values: QueryStringValue[] | null): QueryString {
+        if (values === undefined || values === null) {
+            return this;
+        }
+
+        values.forEach(value => this.append(name, value));
+
+        return this;
+    }
+
+    public delete(name: string): QueryString {
+        this.#builder.delete(name);
+
+        return this;
+    }
+
+    public get(name: string): string | null {
+        return this.#builder.get(name);
+    }
+
+    public getAll(name: string): string[] {
+        return this.#builder.getAll(name);
+    }
+
+    public has(name: string): boolean {
+        return this.#builder.has(name);
+    }
+
+    public set(name: string, value: QueryStringValue): QueryString {
+        return this.#add(this.#builder.set.bind(this.#builder), name, value);
+    }
+
+    #add(fn: ((name: string, value: string) => void), name: string, value: QueryStringValue): QueryString {
+        if (!value && value !== false) {
+            return this;
+        }
+
+        switch (typeof value) {
+            case 'boolean':
+                fn(name, value ? 'true' : 'false');
+                break;
+
+            case 'number':
+                fn(name, value.toString(10));
+                break;
+
+            case 'string':
+                fn(name, value);
+                break;
+        }
+
+        return this;
+    }
+
+    public static builder(): QueryString {
+        return new QueryString();
+    }
+}
+
+type QueryStringValue = boolean | number | string | null;