@azure-net/kit 0.6.7 → 0.8.1

package/dist/core/classMirror/ClassMirror.d.ts

@@ -0,0 +1,3 @@
+export declare class ClassMirror<Target extends object> {
+    constructor(target: Target);
+}

package/dist/core/classMirror/ClassMirror.js

@@ -0,0 +1,19 @@
+export class ClassMirror {
+    constructor(target) {
+        const proto = Object.getPrototypeOf(target);
+        for (const name of Object.getOwnPropertyNames(proto)) {
+            if (name === 'constructor')
+                continue;
+            const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+            if (!descriptor || typeof descriptor.value !== 'function')
+                continue;
+            if (name in this)
+                continue;
+            Object.defineProperty(this, name, {
+                value: descriptor.value.bind(target),
+                configurable: true,
+                writable: true
+            });
+        }
+    }
+}

package/dist/core/classMirror/index.d.ts

@@ -0,0 +1 @@
+export * from './ClassMirror.js';

package/dist/core/classMirror/index.js

@@ -0,0 +1 @@
+export * from './ClassMirror.js';

package/dist/core/index.d.ts

@@ -1,7 +1,8 @@
-export * from './application/index.js';
-export * from './response/index.js';
-export * from './httpService/index.js';
-export * from './datasource/index.js';
+export * from './infra/response/index.js';
+export * from './infra/resource/index.js';
+export * from './infra/httpService/index.js';
+export * from './infra/datasource/index.js';
+export * from './infra/query/index.js';
+export * from './classMirror/index.js';
 export * from './request/index.js';
-export * from './query/index.js';
 export * from './boundaryProvider/index.js';

package/dist/core/index.js

@@ -1,7 +1,8 @@
-export * from './application/index.js';
-export * from './response/index.js';
-export * from './httpService/index.js';
-export * from './datasource/index.js';
+export * from './infra/response/index.js';
+export * from './infra/resource/index.js';
+export * from './infra/httpService/index.js';
+export * from './infra/datasource/index.js';
+export * from './infra/query/index.js';
+export * from './classMirror/index.js';
 export * from './request/index.js';
-export * from './query/index.js';
 export * from './boundaryProvider/index.js';

package/dist/core/infra/datasource/BaseDatasource.d.ts

@@ -0,0 +1,16 @@
+import { HttpService, HttpServiceResponse } from '../httpService/HttpService.js';
+import { QueryBuilder } from '../query/index.js';
+export type CreateRequestCallbackType<T> = (params: {
+    http: HttpService;
+    query: QueryBuilder;
+}) => Promise<HttpServiceResponse<T>>;
+export declare class BaseHttpDatasource {
+    protected readonly httpClient: HttpService;
+    protected readonly query: QueryBuilder;
+    constructor(params: {
+        http?: HttpService;
+        query?: QueryBuilder;
+    });
+    private _createRawRequest;
+    readonly createRawRequest: <T>(callback: CreateRequestCallbackType<T>) => Promise<HttpServiceResponse<T>>;
+}

package/dist/core/{datasource → infra/datasource}/BaseDatasource.js

@@ -7,13 +7,6 @@ export class BaseHttpDatasource {
         this.httpClient = params.http ?? new HttpService({ baseUrl: '' });
         this.query = params.query ?? new QueryBuilder();
     }
-    async createRequest(callback) {
-        return await callback({ http: this.httpClient, query: this.query })
-            .then((response) => response)
-            .catch((err) => {
-            throw err;
-        });
-    }
     async _createRawRequest(callback) {
         return await callback({ http: this.httpClient, query: this.query }).catch((err) => {
             throw err;

package/dist/core/infra/resource/BaseResource.d.ts

@@ -0,0 +1,10 @@
+export type PlainObject<T> = {
+    [K in keyof T as K extends string ? (T[K] extends (...args: unknown[]) => unknown ? never : K) : never]: T[K];
+};
+export interface IDTOMapper<TOutput = never> {
+    toPlainObject(): [TOutput] extends [never] ? PlainObject<this> : TOutput;
+}
+export type Collection<T> = T[];
+export declare class DTOMapper<TOutput = never> implements IDTOMapper<TOutput> {
+    toPlainObject(): [TOutput] extends [never] ? PlainObject<this> : TOutput;
+}

package/dist/core/infra/resource/BaseResource.js

@@ -0,0 +1,5 @@
+export class DTOMapper {
+    toPlainObject() {
+        return { ...this };
+    }
+}

package/dist/core/infra/resource/index.d.ts

@@ -0,0 +1 @@
+export * from './BaseResource.js';

package/dist/core/infra/resource/index.js

@@ -0,0 +1 @@
+export * from './BaseResource.js';

package/dist/core/infra/response/BaseResponse.d.ts

@@ -0,0 +1,34 @@
+import { HttpServiceResponse } from '../../index.js';
+type DeepKeys<T> = T extends object ? {
+    [K in keyof T & string]: T[K] extends object ? K | `${K}.${DeepKeys<T[K]>}` : K;
+}[keyof T & string] : never;
+type DeepValue<T, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? DeepValue<T[Key], Rest> : never : Path extends keyof T ? T[Path] : never;
+type ResponseBuilderState<TData, TMeta = unknown> = {
+    data: TData;
+    meta: TMeta;
+};
+type ArrayElement<T> = T extends readonly (infer E)[] ? E : never;
+export declare class ResponseBuilder<TData = unknown, TMeta = object, TWrapper = TData> {
+    protected readonly response: HttpServiceResponse<TWrapper>;
+    protected state: ResponseBuilderState<TData, TMeta>;
+    constructor(response: HttpServiceResponse<TWrapper>);
+    protected unwrapData(data: TWrapper): TData;
+    mapUsing<TResource>(ResourceClass: new (data: TData) => {
+        toPlainObject(): TResource;
+    }): ResponseBuilder<TResource, TMeta, TWrapper>;
+    mapCollectionUsing<TResource>(ResourceClass: new (data: ArrayElement<TData>) => {
+        toPlainObject(): TResource;
+    }): ResponseBuilder<TResource[], TMeta, TWrapper>;
+    extract<TPath extends DeepKeys<TData>>(path: TPath): ResponseBuilder<DeepValue<TData, TPath>, TMeta, TWrapper>;
+    addMeta<TNewMeta extends Record<string, unknown>>(metaData: TNewMeta | ((current: TMeta) => TNewMeta)): ResponseBuilder<TData, TMeta & TNewMeta, TWrapper>;
+    getData(): TData;
+    get(): {
+        data: TData;
+        meta: TMeta;
+    };
+    getFlatten(): {
+        data: TData;
+    } & TMeta;
+    getRaw(): HttpServiceResponse<TWrapper>;
+}
+export {};

package/dist/core/infra/response/BaseResponse.js

@@ -0,0 +1,81 @@
+import { HttpServiceResponse } from '../../index.js';
+export class ResponseBuilder {
+    response;
+    state;
+    constructor(response) {
+        this.response = response;
+        this.state = {
+            data: this.unwrapData(response.data),
+            meta: {}
+        };
+    }
+    unwrapData(data) {
+        return data;
+    }
+    mapUsing(ResourceClass) {
+        const resource = new ResourceClass(this.state.data);
+        const newResponse = new ResponseBuilder(this.response);
+        newResponse.state = {
+            ...this.state,
+            data: resource.toPlainObject()
+        };
+        return newResponse;
+    }
+    mapCollectionUsing(ResourceClass) {
+        if (!Array.isArray(this.state.data)) {
+            throw new Error('toCollection can only be used when data is an array');
+        }
+        const collection = this.state.data.map((dataElement) => new ResourceClass(dataElement).toPlainObject());
+        const newResponse = new ResponseBuilder(this.response);
+        newResponse.state = {
+            ...this.state,
+            data: collection
+        };
+        return newResponse;
+    }
+    extract(path) {
+        const keys = path.split('.');
+        let result = this.state.data;
+        for (const key of keys) {
+            if (result && typeof result === 'object' && key in result) {
+                result = result[key];
+            }
+            else {
+                throw new Error(`Path "${path}" not found in response data`);
+            }
+        }
+        const newResponse = new ResponseBuilder(this.response);
+        newResponse.state = {
+            ...this.state,
+            data: result
+        };
+        return newResponse;
+    }
+    addMeta(metaData) {
+        const newMeta = typeof metaData === 'function' ? metaData(this.state.meta) : metaData;
+        const newResponse = new ResponseBuilder(this.response);
+        newResponse.state = {
+            ...this.state,
+            meta: { ...this.state.meta, ...newMeta }
+        };
+        return newResponse;
+    }
+    getData() {
+        return this.state.data;
+    }
+    get() {
+        return {
+            data: this.state.data,
+            meta: this.state.meta
+        };
+    }
+    getFlatten() {
+        return {
+            data: this.state.data,
+            ...this.state.meta
+        };
+    }
+    getRaw() {
+        return this.response;
+    }
+}

package/dist/core/provider/dependencies/ErrorHandler.d.ts

@@ -1,5 +1,5 @@
 import { BaseRequest, type RequestErrors } from '../../request/index.js';
-import { HttpServiceError } from '../../httpService/index.js';
+import { HttpServiceError } from '../../infra/httpService/index.js';
 export type AppErrorType = 'http' | 'request' | 'app' | 'abort';
 export interface AppError<T = unknown, D = never> {
     type: AppErrorType;

package/dist/core/provider/dependencies/ErrorHandler.js

@@ -1,5 +1,5 @@
 import { BaseRequest } from '../../request/index.js';
-import { HttpServiceError } from '../../httpService/index.js';
+import { HttpServiceError } from '../../infra/httpService/index.js';
 export const parseHttpError = (error) => {
     return {
         type: 'http',

package/dist/lib/eventModifiers/EventModifiers.d.ts

@@ -1,6 +1,17 @@
 export type EventHandler<E = Event> = (event: E) => void;
-export declare const preventDefault: <E extends Event = Event>(fn: EventHandler<E>) => EventHandler<E>;
-export declare const stopPropagation: <E extends Event = Event>(fn: EventHandler<E>) => EventHandler<E>;
-export declare const stopImmediatePropagation: <E extends Event = Event>(fn: EventHandler<E>) => EventHandler<E>;
-export declare const once: <E extends Event = Event>(fn: EventHandler<E>) => EventHandler<E>;
-export declare const compose: <E extends Event = Event>(...wrappers: Array<(fn: EventHandler<E>) => EventHandler<E>>) => (fn: EventHandler<E>) => EventHandler<E>;
+interface EventModifier<E extends Event = Event> {
+    (fn: () => void): EventHandler<E>;
+    prevent: EventModifier<E>;
+    stop: EventModifier<E>;
+    immediate: EventModifier<E>;
+    once: EventModifier<E>;
+    preventDefault: EventModifier<E>;
+    stopPropagation: EventModifier<E>;
+    stopImmediatePropagation: EventModifier<E>;
+}
+export declare const prevent: EventModifier<Event>;
+export declare const stop: EventModifier<Event>;
+export declare const immediate: EventModifier<Event>;
+export declare const once: EventModifier<Event>;
+export declare const event: EventModifier<Event>;
+export {};

package/dist/lib/eventModifiers/EventModifiers.js

@@ -1,22 +1,31 @@
-export const preventDefault = (fn) => (event) => {
-    event.preventDefault();
-    fn(event);
-};
-export const stopPropagation = (fn) => (event) => {
-    event.stopPropagation();
-    fn(event);
-};
-export const stopImmediatePropagation = (fn) => (event) => {
-    event.stopImmediatePropagation();
-    fn(event);
-};
-export const once = (fn) => {
-    let called = false;
-    return (event) => {
-        if (!called) {
-            called = true;
-            fn(event);
+const createEventModifier = (modifiers = new Set()) => {
+    return new Proxy(() => { }, {
+        get(_, prop) {
+            return createEventModifier(new Set([...modifiers, prop]));
+        },
+        apply(_, __, [fn]) {
+            let executed = false;
+            return (event) => {
+                if (modifiers.has('once') && executed)
+                    return;
+                if (modifiers.has('prevent') || modifiers.has('preventDefault')) {
+                    event.preventDefault();
+                }
+                if (modifiers.has('stop') || modifiers.has('stopPropagation')) {
+                    event.stopPropagation();
+                }
+                if (modifiers.has('immediate') || modifiers.has('stopImmediatePropagation')) {
+                    event.stopImmediatePropagation();
+                }
+                if (modifiers.has('once'))
+                    executed = true;
+                fn();
+            };
         }
-    };
+    });
 };
-export const compose = (...wrappers) => (fn) => wrappers.reduce((acc, wrap) => wrap(acc), fn);
+export const prevent = createEventModifier(new Set(['prevent']));
+export const stop = createEventModifier(new Set(['stop']));
+export const immediate = createEventModifier(new Set(['immediate']));
+export const once = createEventModifier(new Set(['once']));
+export const event = createEventModifier();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "0.6.7",
+  "version": "0.8.1",
   "files": [
     "dist",
     "!dist/**/*.test.*",

package/dist/core/appLayers/AppLayers.d.ts

@@ -1,6 +0,0 @@
-export declare enum AppLayers {
-    INFRASTRUCTURE = "Infrastructure",
-    DOMAIN = "Domain",
-    APPLICATION = "Application",
-    PRESENTATION = "Presentation"
-}

package/dist/core/appLayers/AppLayers.js

@@ -1,7 +0,0 @@
-export var AppLayers;
-(function (AppLayers) {
-    AppLayers["INFRASTRUCTURE"] = "Infrastructure";
-    AppLayers["DOMAIN"] = "Domain";
-    AppLayers["APPLICATION"] = "Application";
-    AppLayers["PRESENTATION"] = "Presentation";
-})(AppLayers || (AppLayers = {}));

package/dist/core/appLayers/index.d.ts

@@ -1 +0,0 @@
-export * from './AppLayers.js';

package/dist/core/appLayers/index.js

@@ -1 +0,0 @@
-export * from './AppLayers.js';

package/dist/core/application/ResourceService.d.ts

@@ -1,11 +0,0 @@
-import { HttpServiceResponse } from '../httpService/index.js';
-export declare class ResourceService {
-    protected transformResponse<TData extends object, TResult = TData, TKey extends keyof TData | undefined = undefined>(requestPromise: Promise<HttpServiceResponse<TData>>, options?: {
-        responseModel?: {
-            new (response: HttpServiceResponse<TData>): {
-                json(): TResult;
-            };
-        };
-        key?: TKey;
-    }): Promise<TKey extends keyof TData ? TData[TKey] : TResult>;
-}

package/dist/core/application/ResourceService.js

@@ -1,13 +0,0 @@
-import { HttpServiceResponse } from '../httpService/index.js';
-export class ResourceService {
-    async transformResponse(requestPromise, options) {
-        const response = await requestPromise;
-        if (options?.responseModel) {
-            return new options.responseModel(response).json();
-        }
-        if (options?.key) {
-            return response.data[options.key];
-        }
-        return response.data;
-    }
-}

package/dist/core/application/index.d.ts

@@ -1 +0,0 @@
-export * from './ResourceService.js';

package/dist/core/application/index.js

@@ -1 +0,0 @@
-export * from './ResourceService.js';

package/dist/core/datasource/BaseDatasource.d.ts

@@ -1,35 +0,0 @@
-import { HttpService, HttpServiceResponse } from '../httpService/HttpService.js';
-import { QueryBuilder } from '../query/index.js';
-export interface IDatasource {
-    /**
-     * Executes a wrapped HTTP request and handles the response.
-     *
-     * @param callback - A function that receives the HttpService and returns a Promise of a response.
-     * @returns A typed HTTP response wrapped in a Promise.
-     */
-    createRequest<T>(callback: <J = T>(params: {
-        http: HttpService;
-        query: QueryBuilder;
-    }) => Promise<HttpServiceResponse<J>>): Promise<HttpServiceResponse<T>>;
-    createRawRequest<T>(callback: (params: {
-        http: HttpService;
-        query: QueryBuilder;
-    }) => Promise<HttpServiceResponse<T>>): Promise<HttpServiceResponse<T>>;
-}
-export declare class BaseHttpDatasource implements IDatasource {
-    protected readonly httpClient: HttpService;
-    protected readonly query: QueryBuilder;
-    constructor(params: {
-        http?: HttpService;
-        query?: QueryBuilder;
-    });
-    createRequest<T>(callback: <J = T>(params: {
-        http: HttpService;
-        query: QueryBuilder;
-    }) => Promise<HttpServiceResponse<J>>): Promise<HttpServiceResponse<T>>;
-    private _createRawRequest;
-    readonly createRawRequest: <T>(callback: (params: {
-        http: HttpService;
-        query: QueryBuilder;
-    }) => Promise<HttpServiceResponse<T>>) => Promise<HttpServiceResponse<T>>;
-}

package/dist/core/response/BaseResponse.d.ts

@@ -1,11 +0,0 @@
-import { HttpServiceResponse } from '../httpService/index.js';
-export interface IBaseResponse<T, D = T> {
-    transform(data: HttpServiceResponse<T>): D;
-    json(): D;
-}
-export declare class BaseResponse<T, D = T> implements IBaseResponse<T, D> {
-    protected response: HttpServiceResponse<T>;
-    constructor(response: HttpServiceResponse<T>);
-    transform(response: HttpServiceResponse<T>): D;
-    json(): D;
-}

package/dist/core/response/BaseResponse.js

@@ -1,13 +0,0 @@
-import { HttpServiceResponse } from '../httpService/index.js';
-export class BaseResponse {
-    response;
-    constructor(response) {
-        this.response = response;
-    }
-    transform(response) {
-        return response.data;
-    }
-    json() {
-        return this.transform(this.response);
-    }
-}