@azure-net/kit 3.1.0 → 3.9.2

package/dist/core/infra/httpService/HttpServiceInstance.js

@@ -0,0 +1,340 @@
+import { BROWSER } from '@azure-net/tools/environment';
+import { RequestContext } from '@azure-net/edges/context';
+export var HttpInstanceFetchMethods;
+(function (HttpInstanceFetchMethods) {
+    HttpInstanceFetchMethods["GET"] = "GET";
+    HttpInstanceFetchMethods["POST"] = "POST";
+    HttpInstanceFetchMethods["PUT"] = "PUT";
+    HttpInstanceFetchMethods["PATCH"] = "PATCH";
+    HttpInstanceFetchMethods["DELETE"] = "DELETE";
+    HttpInstanceFetchMethods["HEAD"] = "HEAD";
+    HttpInstanceFetchMethods["OPTIONS"] = "OPTIONS";
+})(HttpInstanceFetchMethods || (HttpInstanceFetchMethods = {}));
+export class HttpServiceResponse {
+    headers;
+    status;
+    success;
+    data;
+    message;
+    raw;
+    constructor({ headers, status, success, data, message, raw }) {
+        this.headers = headers;
+        this.status = status;
+        this.success = success;
+        this.data = data;
+        this.message = message;
+        this.raw = raw;
+    }
+}
+export var HttpErrorTypes;
+(function (HttpErrorTypes) {
+    HttpErrorTypes["Internal"] = "internal";
+    HttpErrorTypes["External"] = "external";
+})(HttpErrorTypes || (HttpErrorTypes = {}));
+export class HttpServiceError extends Error {
+    data;
+    status;
+    message;
+    type;
+    original;
+    response;
+    constructor({ status = 500, data, message = 'unknown error', original, type = HttpErrorTypes.Internal, response }) {
+        super(message);
+        this.status = status;
+        this.data = data;
+        this.message = message;
+        this.original = original;
+        this.response = response;
+        this.type = type;
+    }
+}
+const stringifyJsonFunc = (data) => {
+    try {
+        return JSON.stringify(data);
+    }
+    catch {
+        return undefined;
+    }
+};
+const isAbsoluteUrl = (value) => /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(value);
+const normalizeHeaders = (headers) => {
+    if (!headers)
+        return new Headers();
+    if (headers instanceof Headers)
+        return new Headers(headers);
+    if (Array.isArray(headers))
+        return new Headers(headers);
+    return new Headers(Object.entries(headers).filter(([, value]) => value !== undefined));
+};
+const normalizeSearchParams = (value) => {
+    if (!value)
+        return new URLSearchParams();
+    if (value instanceof URLSearchParams)
+        return new URLSearchParams(value);
+    if (typeof value === 'string')
+        return new URLSearchParams(value);
+    if (Array.isArray(value)) {
+        const params = new URLSearchParams();
+        for (const [key, rawValue] of value) {
+            params.append(String(key), String(rawValue));
+        }
+        return params;
+    }
+    const params = new URLSearchParams();
+    for (const [key, rawValue] of Object.entries(value)) {
+        if (rawValue === undefined)
+            continue;
+        params.append(key, String(rawValue));
+    }
+    return params;
+};
+const mergeSearchParams = (base, extra) => {
+    if (!base && !extra)
+        return undefined;
+    const result = normalizeSearchParams(base);
+    const next = normalizeSearchParams(extra);
+    for (const [key, value] of next.entries()) {
+        result.append(key, value);
+    }
+    return result;
+};
+const mergeOptions = (base = {}, extra = {}) => {
+    const mergedHeaders = new Headers(normalizeHeaders(base.headers));
+    for (const [key, value] of normalizeHeaders(extra.headers).entries()) {
+        mergedHeaders.set(key, value);
+    }
+    const mergedSearchParams = mergeSearchParams(base.searchParams, extra.searchParams);
+    return {
+        ...base,
+        ...extra,
+        headers: mergedHeaders,
+        searchParams: mergedSearchParams,
+        stringifyJson: extra.stringifyJson ?? base.stringifyJson,
+        onRequest: extra.onRequest ?? base.onRequest,
+        onError: extra.onError ?? base.onError,
+        doFetch: extra.doFetch ?? base.doFetch
+    };
+};
+const mergeQueryToRelativeUrl = (url, searchParams) => {
+    const hashIndex = url.indexOf('#');
+    const hash = hashIndex >= 0 ? url.slice(hashIndex) : '';
+    const urlWithoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+    const queryIndex = urlWithoutHash.indexOf('?');
+    const path = queryIndex >= 0 ? urlWithoutHash.slice(0, queryIndex) : urlWithoutHash;
+    const query = queryIndex >= 0 ? urlWithoutHash.slice(queryIndex + 1) : '';
+    const merged = new URLSearchParams(query);
+    for (const [key, value] of searchParams.entries()) {
+        merged.append(key, value);
+    }
+    const nextQuery = merged.toString();
+    return `${path}${nextQuery ? `?${nextQuery}` : ''}${hash}`;
+};
+const resolveUrl = (target, baseUrl, searchParams) => {
+    if (!baseUrl && !searchParams)
+        return target;
+    let rawUrl = String(target);
+    if (baseUrl) {
+        const base = String(baseUrl);
+        rawUrl = isAbsoluteUrl(rawUrl) ? rawUrl : new URL(rawUrl, base).toString();
+    }
+    if (!searchParams)
+        return rawUrl;
+    const normalizedSearchParams = normalizeSearchParams(searchParams);
+    if (!normalizedSearchParams.size)
+        return rawUrl;
+    if (isAbsoluteUrl(rawUrl)) {
+        const absoluteUrl = new URL(rawUrl);
+        for (const [key, value] of normalizedSearchParams.entries()) {
+            absoluteUrl.searchParams.append(key, value);
+        }
+        return absoluteUrl.toString();
+    }
+    return mergeQueryToRelativeUrl(rawUrl, normalizedSearchParams);
+};
+const parseBodyByFormat = async (response, format) => {
+    switch (format) {
+        case 'blob':
+            return (await response.blob());
+        case 'text':
+            return (await response.text());
+        case 'arrayBuffer':
+            return (await response.arrayBuffer());
+        case 'body':
+            return response.body;
+        case 'json':
+            return (await response.json());
+        default:
+            return (await response.json());
+    }
+};
+const withTimeout = (signal, timeout) => {
+    if (!timeout || timeout <= 0) {
+        return { signal, clear: () => undefined };
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(new Error('Request timeout exceeded')), timeout);
+    const abortBySource = () => controller.abort(signal?.reason);
+    if (signal) {
+        if (signal.aborted) {
+            abortBySource();
+        }
+        else {
+            signal.addEventListener('abort', abortBySource, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        clear: () => {
+            clearTimeout(timer);
+            if (signal)
+                signal.removeEventListener('abort', abortBySource);
+        }
+    };
+};
+const shouldRetryError = (error) => {
+    return error instanceof HttpServiceError && error.type === HttpErrorTypes.External;
+};
+const normalizeUnknownError = (error) => {
+    if (error instanceof Error)
+        return error;
+    return new Error(String(error));
+};
+const parseResponse = async (response, request) => {
+    const raw = request.includeRaw && typeof response?.clone === 'function' ? response?.clone() : undefined;
+    let data;
+    let parseError;
+    try {
+        data = await parseBodyByFormat(response, request.responseFormat);
+    }
+    catch (error) {
+        parseError = normalizeUnknownError(error);
+        data = undefined;
+    }
+    if (!response.ok || parseError) {
+        const message = !response.ok
+            ? `Request failed with status code ${response.status}. ${response.statusText}`
+            : (parseError?.message ?? 'Internal error');
+        throw new HttpServiceError({
+            status: response.status,
+            data,
+            message,
+            type: !response.ok ? HttpErrorTypes.External : HttpErrorTypes.Internal,
+            original: parseError,
+            response: raw ?? response
+        });
+    }
+    return { data, headers: Object.fromEntries(response.headers.entries()), status: response.status, raw };
+};
+const defaultDoFetch = async (request) => {
+    const maxAttempts = Math.max(1, Math.floor(request.retry) + 1);
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        const timeoutState = withTimeout(request.requestInit.signal ?? null, request.timeout);
+        try {
+            const response = await request.fetch(request.url, {
+                ...request.requestInit,
+                method: request.method,
+                headers: request.headers,
+                body: request.body,
+                signal: timeoutState.signal ?? undefined
+            });
+            const { data, headers, status, raw } = await parseResponse(response, request);
+            return new HttpServiceResponse({
+                headers,
+                status,
+                success: true,
+                data,
+                message: 'Request completed',
+                raw
+            });
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= maxAttempts || !shouldRetryError(error)) {
+                throw error;
+            }
+        }
+        finally {
+            timeoutState.clear();
+        }
+    }
+    throw lastError;
+};
+const makeMethod = (method, defaults) => {
+    return async (url, options = {}) => {
+        const merged = mergeOptions(defaults, options);
+        const stringifyJson = merged.stringifyJson ?? stringifyJsonFunc;
+        const fetcher = !BROWSER ? (RequestContext.current()?.event?.fetch ?? fetch) : fetch;
+        const headers = normalizeHeaders(merged.headers);
+        let body = merged.body;
+        if (merged.json !== undefined && body === undefined) {
+            body = stringifyJson(merged.json);
+            if (!headers.has('content-type')) {
+                headers.set('content-type', 'application/json');
+            }
+        }
+        const responseFormat = merged.responseFormat ?? 'json';
+        if (responseFormat === 'json' && !headers.has('accept')) {
+            headers.set('accept', 'application/json');
+        }
+        const normalizedRequest = {
+            url: resolveUrl(url, merged.prefixUrl, merged.searchParams),
+            method,
+            headers,
+            body,
+            responseFormat,
+            includeRaw: merged.includeRaw ?? false,
+            timeout: merged.timeout ?? 20000,
+            retry: merged.retry ?? 0,
+            stringifyJson,
+            fetch: fetcher,
+            requestInit: {
+                cache: merged.cache,
+                credentials: merged.credentials,
+                integrity: merged.integrity,
+                keepalive: merged.keepalive,
+                mode: merged.mode,
+                priority: merged.priority,
+                redirect: merged.redirect,
+                referrer: merged.referrer,
+                referrerPolicy: merged.referrerPolicy,
+                signal: merged.signal,
+                window: merged.window
+            }
+        };
+        const onRequest = options.onRequest ?? defaults.onRequest;
+        if (onRequest) {
+            await onRequest(normalizedRequest);
+        }
+        const doFetch = merged.doFetch ?? defaults.doFetch ?? defaultDoFetch;
+        try {
+            return await doFetch(normalizedRequest);
+        }
+        catch (error) {
+            const normalizedError = error instanceof HttpServiceError
+                ? error
+                : new HttpServiceError({
+                    data: undefined,
+                    message: normalizeUnknownError(error).message ?? 'Unknown error',
+                    original: normalizeUnknownError(error)
+                });
+            const onError = options.onError ?? defaults.onError;
+            if (!onError)
+                throw normalizedError;
+            await onError(normalizedError, normalizedRequest);
+            throw normalizedError;
+        }
+    };
+};
+export const createHttpServiceInstance = (config = {}) => {
+    const defaults = { ...config };
+    return {
+        get: makeMethod(HttpInstanceFetchMethods.GET, defaults),
+        post: makeMethod(HttpInstanceFetchMethods.POST, defaults),
+        put: makeMethod(HttpInstanceFetchMethods.PUT, defaults),
+        delete: makeMethod(HttpInstanceFetchMethods.DELETE, defaults),
+        patch: makeMethod(HttpInstanceFetchMethods.PATCH, defaults),
+        head: makeMethod(HttpInstanceFetchMethods.HEAD, defaults),
+        options: makeMethod(HttpInstanceFetchMethods.OPTIONS, defaults)
+    };
+};

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

@@ -1,2 +1,2 @@
-export * from './HttpService.js';
 export * from './Statuses.js';
+export * from './HttpServiceInstance.js';

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

@@ -1,2 +1,2 @@
-export * from './HttpService.js';
 export * from './Statuses.js';
+export * from './HttpServiceInstance.js';

package/dist/core/infra/query/QueryBuilder.d.ts

@@ -1,25 +1,13 @@
 export type ArrayFormat = 'repeat' | 'brackets' | 'comma' | 'json';
 export type ObjectFormat = 'default' | 'nested-brackets';
-export interface IQueryBuilder {
-    build(query: Record<string, unknown>, opts?: {
-        arrayFormat?: ArrayFormat;
-        objectFormat?: ObjectFormat;
-    }): string;
-    transform(object: object): object;
+export interface IQueryBuilderSettings<TTransformInput extends object = object> {
+    delimiter?: boolean;
+    arrayFormat?: ArrayFormat;
+    objectFormat?: ObjectFormat;
+    transform?: (obj: TTransformInput) => object;
 }
-export declare class QueryBuilder implements IQueryBuilder {
-    private readonly defaultArrayFormat;
-    private readonly defaultObjectFormat;
-    constructor(options?: {
-        arrayFormat?: ArrayFormat;
-        objectFormat?: ObjectFormat;
-    });
-    transform(object: object): object;
-    build(query?: object, opts?: {
-        delimiter?: boolean;
-        arrayFormat?: ArrayFormat;
-        objectFormat?: ObjectFormat;
-    }): string;
-    private serialize;
-    private encodeArray;
+export interface IQueryBuilderInstance<TTransformInput extends object = object> {
+    toString: (query: object, settings?: IQueryBuilderSettings<TTransformInput>) => string;
+    toSearchParams: (query: object, settings?: Omit<IQueryBuilderSettings<TTransformInput>, 'delimiter'>) => URLSearchParams;
 }
+export declare const createQueryInstance: <TTransformInput extends object = object>(defaults?: IQueryBuilderSettings<TTransformInput>) => IQueryBuilderInstance<TTransformInput>;

package/dist/core/infra/query/QueryBuilder.js

@@ -1,57 +1,70 @@
-export class QueryBuilder {
-    defaultArrayFormat;
-    defaultObjectFormat;
-    constructor(options) {
-        this.defaultArrayFormat = options?.arrayFormat ?? 'repeat';
-        this.defaultObjectFormat = options?.objectFormat ?? 'default';
+import { AzureNetKitInternalError } from '../../shared/appError/AppError.js';
+const normalizeSettings = (base, override) => {
+    return {
+        delimiter: override?.delimiter ?? base?.delimiter ?? true,
+        arrayFormat: override?.arrayFormat ?? base?.arrayFormat ?? 'repeat',
+        objectFormat: override?.objectFormat ?? base?.objectFormat ?? 'default',
+        transform: override?.transform ?? base?.transform
+    };
+};
+const encodeQuery = (entries) => entries.map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join('&');
+const encodeArrayEntries = (key, values, arrayFormat) => {
+    const cleanValues = values.filter((v) => v !== null && v !== undefined).map((v) => String(v));
+    switch (arrayFormat) {
+        case 'repeat':
+            return cleanValues.map((v) => [key, v]);
+        case 'brackets':
+            return cleanValues.map((v) => [`${key}[]`, v]);
+        case 'comma':
+            return [[key, cleanValues.join(',')]];
+        case 'json':
+            return [[key, JSON.stringify(cleanValues)]];
+        default:
+            throw new AzureNetKitInternalError(`[QueryInstance] Unsupported array format: ${arrayFormat}`);
     }
-    transform(object) {
-        return object;
-    }
-    build(query = {}, opts) {
-        const params = this.transform(query);
-        const arrayFormat = opts?.arrayFormat ?? this.defaultArrayFormat;
-        const objectFormat = opts?.objectFormat ?? this.defaultObjectFormat;
-        const parts = this.serialize(params, arrayFormat, objectFormat);
-        const delimiter = opts?.delimiter ?? true;
-        return delimiter && parts.length ? `?${parts.join('&')}` : parts.join('&');
-    }
-    serialize(obj, arrayFormat, objectFormat, prefix = '') {
-        const parts = [];
-        for (const [key, value] of Object.entries(obj)) {
-            if (value === null || value === undefined)
-                continue;
-            const fullKey = prefix ? (objectFormat === 'nested-brackets' ? `${prefix}[${key}]` : `${prefix}.${key}`) : key;
-            if (Array.isArray(value)) {
-                parts.push(...this.encodeArray(fullKey, value, arrayFormat));
-            }
-            else if (typeof value === 'object' && !(value instanceof Date)) {
-                if (objectFormat === 'nested-brackets') {
-                    parts.push(...this.serialize(value, arrayFormat, objectFormat, fullKey));
-                }
-                else {
-                    parts.push(`${encodeURIComponent(fullKey)}=${encodeURIComponent(JSON.stringify(value))}`);
-                }
+};
+const serializeEntries = (obj, arrayFormat, objectFormat, prefix = '') => {
+    const entries = [];
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === null || value === undefined)
+            continue;
+        const fullKey = prefix ? (objectFormat === 'nested-brackets' ? `${prefix}[${key}]` : `${prefix}.${key}`) : key;
+        if (Array.isArray(value)) {
+            entries.push(...encodeArrayEntries(fullKey, value, arrayFormat));
+            continue;
+        }
+        if (typeof value === 'object' && !(value instanceof Date)) {
+            if (objectFormat === 'nested-brackets') {
+                entries.push(...serializeEntries(value, arrayFormat, objectFormat, fullKey));
             }
             else {
-                parts.push(`${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`);
+                entries.push([fullKey, JSON.stringify(value)]);
             }
+            continue;
         }
-        return parts;
+        entries.push([fullKey, String(value)]);
     }
-    encodeArray(key, arr, arrayFormat) {
-        const cleanArray = arr.filter((v) => v !== null && v !== undefined).map(String);
-        switch (arrayFormat) {
-            case 'repeat':
-                return cleanArray.map((v) => `${encodeURIComponent(key)}=${encodeURIComponent(v)}`);
-            case 'brackets':
-                return cleanArray.map((v) => `${encodeURIComponent(key)}[]=${encodeURIComponent(v)}`);
-            case 'comma':
-                return [`${encodeURIComponent(key)}=${encodeURIComponent(cleanArray.join(','))}`];
-            case 'json':
-                return [`${encodeURIComponent(key)}=${encodeURIComponent(JSON.stringify(cleanArray))}`];
-            default:
-                throw new Error(`Unsupported array format: ${arrayFormat}`);
-        }
+    return entries;
+};
+const toSearchParamsWithSettings = (query, settings) => {
+    const source = settings.transform ? settings.transform(query) : query;
+    const entries = serializeEntries(source, settings.arrayFormat, settings.objectFormat);
+    const params = new URLSearchParams();
+    for (const [key, value] of entries) {
+        params.append(key, value);
     }
-}
+    return params;
+};
+export const createQueryInstance = (defaults) => {
+    return {
+        toSearchParams: (query, settings) => {
+            const resolved = normalizeSettings(defaults, settings);
+            return toSearchParamsWithSettings(query, resolved);
+        },
+        toString: (query, settings) => {
+            const resolved = normalizeSettings(defaults, settings);
+            const serialized = encodeQuery(Array.from(toSearchParamsWithSettings(query, resolved).entries()));
+            return resolved.delimiter && serialized ? `?${serialized}` : serialized;
+        }
+    };
+};

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

@@ -1,3 +1,4 @@
+import { AzureNetKitInternalError } from '../../shared/appError/AppError.js';
 export class ResponseBuilder {
     response;
     state;
@@ -22,7 +23,7 @@ export class ResponseBuilder {
     }
     mapCollectionUsing(ResourceClass) {
         if (!Array.isArray(this.state.data)) {
-            throw new Error('toCollection can only be used when data is an array');
+            throw new AzureNetKitInternalError('[ResponseBuilder] Method "mapCollectionUsing" can only be used when data is an array');
         }
         const collection = this.state.data.map((dataElement) => new ResourceClass(dataElement).toPlainObject());
         const newResponse = new this.constructor(this.response);
@@ -40,7 +41,7 @@ export class ResponseBuilder {
                 result = result[key];
             }
             else {
-                throw new Error(`Path "${path}" not found in response data`);
+                throw new AzureNetKitInternalError(`[ResponseBuilder] Failed to extract: path "${path}" not found in response data`);
             }
         }
         const newResponse = new this.constructor(this.response);

package/dist/core/infra.d.ts

@@ -0,0 +1,6 @@
+export { createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type HttpInstanceNormalizedRequest, type HttpInstanceOnRequest, type HttpInstanceOnError, type HttpInstanceDoFetch, type HttpInstanceRequestMethod } from './infra/httpService/HttpServiceInstance.js';
+export { HttpStatusCode } from './infra/httpService/Statuses.js';
+export { BaseHttpDatasource, type CreateRequestCallbackType } from './infra/datasource/BaseDatasource.js';
+export { ResponseBuilder } from './infra/response/BaseResponse.js';
+export { createQueryInstance, type IQueryBuilderInstance, type ArrayFormat, type ObjectFormat, type IQueryBuilderSettings } from './infra/query/QueryBuilder.js';
+export { DTOMapper, type IDTOMapper } from './infra/resource/BaseResource.js';

package/dist/core/infra.js

@@ -0,0 +1,6 @@
+export { createHttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse } from './infra/httpService/HttpServiceInstance.js';
+export { HttpStatusCode } from './infra/httpService/Statuses.js';
+export { BaseHttpDatasource } from './infra/datasource/BaseDatasource.js';
+export { ResponseBuilder } from './infra/response/BaseResponse.js';
+export { createQueryInstance } from './infra/query/QueryBuilder.js';
+export { DTOMapper } from './infra/resource/BaseResource.js';

package/dist/core/shared/appError/AppError.d.ts

@@ -0,0 +1,30 @@
+import { HttpServiceError } from '../../infra/httpService/HttpServiceInstance.js';
+import { type RequestErrors } from '../../delivery/schema/Schema.js';
+export declare enum ErrorTypes {
+    Http = "Http",
+    Schema = "Schema",
+    KitInternalError = "AzureNetKitInternal",
+    AsyncHelperError = "AsyncHelperError",
+    Unknown = "Unknown"
+}
+export declare class AzureNetKitInternalError extends Error {
+}
+export interface IAppError<T = unknown> {
+    type: ErrorTypes;
+    message: string;
+    validation?: RequestErrors<T>;
+    external: boolean;
+    appErrorConvert?: boolean;
+}
+export declare class AppError<T = unknown> extends Error {
+    error: Error;
+    type: ErrorTypes;
+    message: string;
+    external: boolean;
+    validation?: RequestErrors<T>;
+    constructor(error: Error);
+    tryToGetExternalError<HttpServiceDataType = unknown>(): HttpServiceError<HttpServiceDataType> | undefined;
+    redeclareValidation<D = T>(validation: D): void;
+    toPlainObject<CustomData extends object>(custom?: CustomData): IAppError<T> & CustomData;
+    private parseError;
+}

package/dist/core/shared/appError/AppError.js

@@ -0,0 +1,66 @@
+import { HttpErrorTypes, HttpServiceError } from '../../infra/httpService/HttpServiceInstance.js';
+import { SchemaFail } from '../../delivery/schema/Schema.js';
+import { AsyncHelperError } from '../../delivery/injectableDependencies/AsyncHelpers.js';
+export var ErrorTypes;
+(function (ErrorTypes) {
+    ErrorTypes["Http"] = "Http";
+    ErrorTypes["Schema"] = "Schema";
+    ErrorTypes["KitInternalError"] = "AzureNetKitInternal";
+    ErrorTypes["AsyncHelperError"] = "AsyncHelperError";
+    ErrorTypes["Unknown"] = "Unknown";
+})(ErrorTypes || (ErrorTypes = {}));
+export class AzureNetKitInternalError extends Error {
+}
+export class AppError extends Error {
+    error;
+    type = ErrorTypes.Unknown;
+    message;
+    external = false;
+    validation;
+    constructor(error) {
+        super(error.message);
+        this.error = error;
+        this.message = error.message ?? 'Unknown error';
+        this.parseError();
+    }
+    tryToGetExternalError() {
+        if (this.external && this.error instanceof HttpServiceError) {
+            return this.error;
+        }
+        return undefined;
+    }
+    redeclareValidation(validation) {
+        this.validation = validation;
+    }
+    toPlainObject(custom) {
+        const customData = custom ?? {};
+        return {
+            message: this.message,
+            type: this.type,
+            external: this.external,
+            validation: this.validation,
+            appErrorConvert: true,
+            ...customData
+        };
+    }
+    parseError() {
+        switch (true) {
+            case this.error instanceof HttpServiceError:
+                this.type = ErrorTypes.Http;
+                this.external = this.error.type === HttpErrorTypes.External;
+                break;
+            case this.error instanceof SchemaFail:
+                this.type = ErrorTypes.Schema;
+                this.validation = this.error.getSelfTypedData();
+                break;
+            case this.error instanceof AzureNetKitInternalError:
+                this.type = ErrorTypes.KitInternalError;
+                break;
+            case this.error instanceof AsyncHelperError:
+                this.type = ErrorTypes.AsyncHelperError;
+                break;
+            default:
+                this.type = ErrorTypes.Unknown;
+        }
+    }
+}

package/dist/core/shared/appEventBus/EventBus.d.ts

@@ -1,4 +1,4 @@
-import { EventBus } from 'azure-net-tools';
+import { EventBus } from '@azure-net/tools';
 export declare const AppEvents: () => {
     bus: EventBus<any>;
 };

package/dist/core/shared/appEventBus/EventBus.js

@@ -1,7 +1,7 @@
-import { EventBus } from 'azure-net-tools';
-import { createPresenter } from 'edges-svelte';
+import { EventBus } from '@azure-net/tools';
+import { createPresenter } from '@azure-net/edges';
 export const AppEvents = createPresenter(() => {
-    const appEventBus = new EventBus({ OnAsyncHelperError: [] });
+    const appEventBus = new EventBus({});
     return {
         bus: appEventBus
     };

package/dist/core/shared/boundaryProvider/Provider.d.ts

@@ -1,7 +1,7 @@
-type ServiceFactory<T> = () => T | Promise<T>;
+type ServiceFactory<T> = () => T;
 type ServiceMap = Record<string, ServiceFactory<unknown>>;
 type ResolvedServices<T extends ServiceMap> = {
-    [K in keyof T]: Awaited<ReturnType<T[K]>>;
+    [K in keyof T]: ReturnType<T[K]>;
 };
 type InferProviderType<T> = T extends ProviderWithType<infer S> ? ResolvedServices<S> : never;
 export interface ProviderWithType<T extends ServiceMap> {