@basmilius/http-client 1.13.0 → 2.2.0

package/src/decorator/dto/instanceProxy.ts

@@ -0,0 +1,89 @@
+import { ENABLE_GET_LOGGING, ENABLE_SET_LOGGING } from './constant';
+import { areEqual, markDtoDirty, relateValueTo, trackDto, triggerDto, unrelateValueFrom } from './helper';
+import { DESCRIPTORS, NAME, PROPERTIES, PROXY } from './symbols';
+import arrayProxy from './arrayProxy';
+import type DtoInstance from './instance';
+
+export default {
+    /**
+     * Trap for when a dto property is being accessed. The property
+     * access is being tracked for further updates. If the dto has
+     * any child dtos, a relationship will be added between them.
+     */
+    get(target: DtoInstance<unknown>, key: string | symbol, receiver: any): unknown {
+        if (key === PROXY) {
+            return true;
+        }
+
+        if (typeof key === 'symbol') {
+            return Reflect.get(target, key, receiver);
+        }
+
+        const descriptor = target[DESCRIPTORS][key];
+
+        if (!descriptor || !descriptor.get) {
+            return Reflect.get(target, key, receiver);
+        }
+
+        const value = descriptor.get.call(target);
+
+        ENABLE_GET_LOGGING && console.log(`%c@dto %c${target[NAME]} %cget`, 'color: #0891b2', 'color: #059669', 'color: #1d4ed8', key);
+        trackDto(target, key);
+
+        relateValueTo(target, key, value);
+
+        return value;
+    },
+
+    /**
+     * Trap for when a descriptor of a dto property is requested.
+     */
+    getOwnPropertyDescriptor(target: DtoInstance<unknown>, key: string | symbol): PropertyDescriptor | undefined {
+        return target[DESCRIPTORS][key];
+    },
+
+    /**
+     * Trap for when the keys of a dto are requested.
+     */
+    ownKeys(target: DtoInstance<unknown>) {
+        return target[PROPERTIES];
+    },
+
+    /**
+     * Trap for when a dto property is being updated. This will
+     * mark the dto dirty and trigger an update. If an array is
+     * passed, that array will be made reactive as well.
+     */
+    set(target: DtoInstance<unknown>, key: string | symbol, value: unknown, receiver: any): boolean {
+        if (typeof key === 'symbol') {
+            return Reflect.set(target, key, value, receiver);
+        }
+
+        const descriptor = target[DESCRIPTORS][key];
+
+        if (!descriptor || !descriptor.set) {
+            return Reflect.set(target, key, value, receiver);
+        }
+
+        const oldValue = descriptor.get?.call(target) ?? undefined;
+
+        if (areEqual(value, oldValue)) {
+            return true;
+        }
+
+        unrelateValueFrom(target, oldValue);
+
+        if (Array.isArray(value) && !value[PROXY]) {
+            value = new Proxy(value, arrayProxy);
+        }
+
+        ENABLE_SET_LOGGING && console.log(`%c@dto %c${target[NAME]} %cset`, 'color: #0891b2', 'color: #059669', 'color: #1d4ed8', key, {value});
+        descriptor.set.call(target, value);
+
+        relateValueTo(target, key, value);
+        markDtoDirty(target, key);
+        triggerDto(target, key, value, oldValue);
+
+        return true;
+    }
+} satisfies ProxyHandler<DtoInstance<unknown>>;

package/src/decorator/dto/map.ts

@@ -0,0 +1,4 @@
+import type { Constructor } from '@basmilius/utils';
+import type DtoInstance from './instance';
+
+export const DTO_CLASS_MAP: Record<string, Constructor<DtoInstance<unknown>>> = {};

package/src/decorator/dto/refProxy.ts

@@ -0,0 +1,61 @@
+import type { Ref } from 'vue';
+import { PROXY } from './symbols';
+import type DtoInstance from './instance';
+
+export default {
+    /**
+     * Trap for when a ref property is being accessed. The property
+     * access is being tracked for further updates. If the requested
+     * property is not a part of {Ref}, the get is proxied to the
+     * underlying dto instance.
+     *
+     * A little trick with __v_isRef is done here, all the features
+     * of refs are used by our dto, but we don't want Vue to treat
+     * it as a ref. We return false here to trick Vue.
+     */
+    get(target: Ref<DtoInstance<unknown>>, key: string | symbol, receiver: any): unknown {
+        if (key === '__v_isRef') {
+            return false;
+        }
+
+        if (key === PROXY) {
+            return true;
+        }
+
+        if (key in target) {
+            return Reflect.get(target, key, receiver);
+        }
+
+        return Reflect.get(target.value, key);
+    },
+
+    /**
+     * Trap for when a descriptor of a property is requested, that
+     * request is proxied to the underlying dto.
+     */
+    getOwnPropertyDescriptor(target: Ref<DtoInstance<unknown>>, key: string | symbol): PropertyDescriptor | undefined {
+        return Reflect.getOwnPropertyDescriptor(target.value, key);
+    },
+
+    /**
+     * Trap for when the keys of the ref are requested, that request
+     * is proxied to the underlying dto.
+     */
+    ownKeys(target: Ref<DtoInstance<unknown>>) {
+        return Reflect.ownKeys(target.value);
+    },
+
+    /**
+     * Trap for when a ref property is being updated. If the property
+     * is not part of {Ref}, the set is proxied to the underlying dto
+     * instance. In that proxy, the dto will be marked dirty and an
+     * update is triggered.
+     */
+    set(target: Ref<DtoInstance<unknown>>, key: string | symbol, value: unknown, receiver: any): boolean {
+        if (key in target) {
+            return Reflect.set(target, key, value, receiver);
+        }
+
+        return Reflect.set(target.value, key, value);
+    }
+} satisfies ProxyHandler<Ref<DtoInstance<unknown>>>;

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

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

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 total(): number {
+        return this.#total;
+    }
+
+    readonly #items: T[];
+    readonly #page: number;
+    readonly #pageSize: number;
+    readonly #pages: number;
+    readonly #total: number;
+
+    constructor(items: T[], page: number, pageSize: number, pages: number, total: number) {
+        this.#items = items;
+        this.#page = page;
+        this.#pageSize = pageSize;
+        this.#pages = pages;
+        this.#total = total;
+    }
+}

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);
+    }
+}