@azure-net/kit 6.0.0-next.10 → 6.0.0-next.12

package/README.md

@@ -55,10 +55,11 @@ skips checks. Review `.gitignore` before staging.
 ## Class Presenters And Async Helpers
 
 Import `createAsyncResource` and `createAsyncAction` directly from
-`@azure-net/kit/delivery`. `createAsyncHelpers()` has been removed. The error hook
-configured by `createApp().useAzureNetKitError` is still resolved per execution;
-there is no per-presenter parser or shared server error state. A custom error
-payload can be typed as the third generic: `createAsyncAction<Response, Request, CustomError>()`.
+`@azure-net/kit/delivery`. Helpers execute the action once and support `beforeSend`,
+`onSuccess`, `onError` and `fallbackResponse`. Resources additionally support `reject`.
+Schema failures are converted locally to `error.validation`. There is no global
+error resolver, `useAzureNetKitError`, or helper-level retry. Exceptions thrown by
+`onSuccess` or `onError` propagate unchanged, without replaying the action.
 
 ```ts
 import { RegisterProvider, createAsyncResource } from '@azure-net/kit/delivery';
@@ -373,3 +374,59 @@ Declare roots once, rather than creating new roots per component render.
 `name` is now a symbol, not a serializable string. Its description is for diagnostics
 only; equal descriptions never share a cache. Existing string keys passed directly
 to `CreateServiceContainer` and `cleanupProvider` remain supported.
+
+## HTTP Retries
+
+Retries belong to `HttpServiceInstance`, including calls made directly from use
+cases. With no `retry` option, a failed request is not repeated. `limit` counts
+additional attempts: `limit: 1` means at most two HTTP attempts.
+
+```ts
+const http = new HttpServiceInstance({
+	onRequest(request) {
+		const token = readAccessToken();
+		if (token) request.headers.set('Authorization', `Bearer ${token}`);
+	},
+	retry: {
+		limit: 1,
+		statuses: [401],
+		async shouldRetry({ error }) {
+			if (!isExpiredAccessToken(error.data)) return false;
+			const refreshed = await http.post('/api/auth/refresh', {
+				json: { refreshToken: readRefreshToken() },
+				retry: { limit: 0 }
+			});
+			saveTokens(refreshed.data);
+			return true;
+		}
+	}
+});
+```
+
+Token helpers above are application-defined. Read/write tokens within the current
+request on SSR, never in shared module-level user state. Coordinate concurrent
+refreshes per session/request as appropriate; the generic HTTP client does not
+implement token rotation or cross-tab coordination.
+
+- `{ limit: N }` retries any failed HTTP attempt, including network failures.
+- `statuses` restricts retries to those error statuses; `[]` allows none.
+- `shouldRetry` runs only after the status filter and only while budget remains.
+  Both synchronous and asynchronous booleans are accepted.
+- Per-request `retry` replaces the entire default policy. Use `{ limit: 0 }` to
+  disable it, **especially for refresh requests made inside `shouldRetry`**.
+  A nested HTTP call has its own budget; forgetting this override can recurse.
+- `onRequest` runs before every attempt so refreshed credentials are read again.
+  `onResponse` runs once on success; `onError` runs once on terminal HTTP failure,
+  not for intermediate failures that recover successfully.
+- Exceptions from hooks (including `shouldRetry`) propagate without further
+  recovery. They are not treated as another failed transport attempt.
+- Cancelled requests and streaming request bodies are never replayed. Cancellation
+  is checked again after awaiting recovery; the callback must manage its own async
+  work and cancellation if needed.
+- `limit` must be a finite non-negative safe integer. There is no implicit retry
+  delay/backoff. Timeout is applied separately to each HTTP attempt.
+
+Retries are opt-in for all HTTP methods. Do not blindly retry writes after network
+errors: the server may already have applied them. Use a narrow status/code policy
+or backend-supported idempotency keys. Numerical `retry: 3` is no longer supported;
+write `retry: { limit: 3 }` instead.

package/dist/delivery/index.d.ts

@@ -1,4 +1,4 @@
-export { createAsyncAction, createAsyncResource, type AsyncActionSettings, type AsyncHelperRetry, type AsyncResourceSettings, type AsyncActionResponse } from './injectable-dependencies/index.js';
+export { createAsyncAction, createAsyncResource, type AsyncActionSettings, type AsyncResourceSettings, type AsyncActionResponse } from './injectable-dependencies/index.js';
 export { RegisterProvider, type ProviderLifecycle, type RegisterProviderOptions, type ProviderMethodKey } from './presenter/RegisterProvider.js';
 export { Bound } from './presenter/Bound.js';
 export { createSchemaFactory, schema, type Schema, type RequestErrors, type ISchemaError, type ValidationResult, type ValidationRuleResult, type ValidationParams, type ValidationMessage, type ValidationErrorsMap } from './schema/index.js';

package/dist/delivery/injectable-dependencies/AsyncHelpers.d.ts

@@ -1,5 +1,4 @@
-import { type AppError, type IAppError } from '../../shared/app-error/AppError.js';
-export type { AsyncHelperRetry } from '../../shared/app-error/ErrorRuntime.js';
+import { AppError, type IAppError } from '../../shared/app-error/AppError.js';
 export interface AsyncActionResponse<T, D = never, ErrorResult = Record<never, never>> {
     success: boolean;
     response: T;
@@ -20,3 +19,4 @@ export interface AsyncResourceSettings<Res = never, Req = never, ErrorResult = A
 }
 export declare const createAsyncAction: <Res = never, Req = never, ErrorResult extends object = Record<never, never>>(action: Action<Res>, args?: AsyncActionSettings<Res, Req, ErrorResult>) => Promise<AsyncActionResponse<Res, Req, ErrorResult>>;
 export declare const createAsyncResource: <Res = never, Req = never, ErrorResult extends object = Record<never, never>>(action: Action<Res>, args?: AsyncResourceSettings<Res, Req, ErrorResult>) => Promise<Res>;
+export {};

package/dist/delivery/injectable-dependencies/AsyncHelpers.js

@@ -1,23 +1,9 @@
-import { AsyncHelperError } from '../../shared/app-error/AppError.js';
-import { resolveAzureNetKitError } from '../../shared/app-error/ErrorRuntime.js';
+import { AsyncHelperError, AppError } from '../../shared/app-error/AppError.js';
 const normalizeError = (err) => (err instanceof Error ? err : new Error(String(err)));
-const prepareErrors = async (error, retry) => {
-    let retryResult = undefined;
-    const retryFunc = async () => {
-        if (retry) {
-            return await retry()
-                .then((res) => {
-                retryResult = res;
-                return undefined;
-            })
-                .catch((err) => normalizeError(err));
-        }
-    };
-    const parsedError = await resolveAzureNetKitError(normalizeError(error), {
-        can: !!retry,
-        call: retry ? () => retryFunc() : undefined
-    });
-    return { error: parsedError, retryResult };
+const prepareError = (error) => {
+    const normalized = normalizeError(error);
+    const appError = normalized instanceof AppError ? normalized : new AppError(normalized);
+    return appError.toPlainObject();
 };
 const beforeSendResolver = async (settings) => {
     if (!settings?.beforeSend)
@@ -55,7 +41,7 @@ const beforeSendResolver = async (settings) => {
     });
     if (!aborted)
         return undefined;
-    const { error } = await prepareErrors(abortReason ?? new AsyncHelperError('Aborted in beforeSend'));
+    const error = prepareError(abortReason ?? new AsyncHelperError('Aborted in beforeSend'));
     return {
         success: false,
         error,
@@ -66,39 +52,18 @@ export const createAsyncAction = async (action, args) => {
     const beforeSendResult = await beforeSendResolver(args);
     if (beforeSendResult)
         return beforeSendResult;
-    const executeAction = async () => {
-        const response = await Promise.resolve(action());
-        return { response, success: true };
-    };
-    const handleFailure = async (err, retry) => {
-        const { error, retryResult } = await prepareErrors(normalizeError(err), retry);
-        if (retryResult) {
-            return completeSuccess(retryResult);
-        }
-        const result = { error, response: args?.fallbackResponse, success: false };
-        try {
-            await args?.onError?.(result);
-        }
-        catch (onErrorException) {
-            throw await resolveAzureNetKitError(new AsyncHelperError('onError caught exception', { cause: normalizeError(onErrorException) }));
-        }
-        return result;
-    };
-    const completeSuccess = async (result) => {
-        try {
-            await args?.onSuccess?.(result);
-            return result;
-        }
-        catch (err) {
-            return handleFailure(err);
-        }
-    };
+    let response;
     try {
-        return completeSuccess(await executeAction());
+        response = await action();
     }
     catch (err) {
-        return handleFailure(err, executeAction);
+        const result = { error: prepareError(err), response: args?.fallbackResponse, success: false };
+        await args?.onError?.(result);
+        return result;
     }
+    const result = { response, success: true };
+    await args?.onSuccess?.(result);
+    return result;
 };
 export const createAsyncResource = async (action, args) => {
     const result = await createAsyncAction(action, args);

package/dist/infra/http-service/HttpServiceInstance.d.ts

@@ -55,7 +55,7 @@ export interface IHttpInstanceNormalizedRequest {
     responseFormat: 'json' | 'blob' | 'text' | 'arrayBuffer' | 'body';
     includeRaw: boolean;
     timeout: number | false;
-    retry: number;
+    retry?: IHttpInstanceRetryOptions;
     stringifyJson: (data: unknown) => string | undefined;
     fetch: typeof fetch;
     requestInit: Omit<RequestInit, 'method' | 'headers' | 'body'>;
@@ -63,6 +63,14 @@ export interface IHttpInstanceNormalizedRequest {
 export type IHttpInstanceOnRequest = (request: IHttpInstanceNormalizedRequest) => void | Promise<void>;
 export type IHttpInstanceOnError = (error: HttpServiceError<unknown>, request: IHttpInstanceNormalizedRequest) => void | Promise<void>;
 export type IHttpInstanceDoFetch = <T = unknown>(request: IHttpInstanceNormalizedRequest) => Promise<IHttpServiceResponse<T>>;
+export interface IHttpInstanceRetryOptions {
+    /** Number of additional attempts. Zero disables retries, including inherited policies. */
+    limit: number;
+    statuses?: readonly number[];
+    shouldRetry?: (context: {
+        error: HttpServiceError<unknown>;
+    }) => boolean | Promise<boolean>;
+}
 export interface IHttpInstanceOptions<T = unknown> extends Omit<RequestInit, 'headers' | 'method'> {
     headers?: NonNullable<RequestInit['headers']> | Record<string, string | undefined>;
     json?: unknown;
@@ -70,7 +78,7 @@ export interface IHttpInstanceOptions<T = unknown> extends Omit<RequestInit, 'he
     searchParams?: SearchParamsOption;
     prefixUrl?: URL | string;
     timeout?: number | false;
-    retry?: number;
+    retry?: IHttpInstanceRetryOptions;
     includeRaw?: boolean;
     responseFormat?: 'json' | 'blob' | 'text' | 'arrayBuffer' | 'body';
     onRequest?: IHttpInstanceOnRequest;

package/dist/infra/http-service/HttpServiceInstance.js

@@ -196,15 +196,6 @@ const withTimeout = (signal, timeout) => {
         }
     };
 };
-const shouldRetryError = (error) => {
-    if (error instanceof Error && error.name === 'AbortError')
-        return false;
-    if (error instanceof TypeError)
-        return true;
-    if (!(error instanceof HttpServiceError) || error.type !== HttpErrorTypes.External)
-        return false;
-    return error.status === 408 || error.status === 425 || error.status === 429 || error.status >= 500;
-};
 const normalizeUnknownError = (error) => {
     if (error instanceof Error)
         return error;
@@ -239,39 +230,21 @@ const parseResponse = async (response, request) => {
     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();
-        }
+    const timeoutState = withTimeout(request.requestInit.signal, 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 });
+    }
+    finally {
+        timeoutState.clear();
     }
-    throw lastError;
 };
 const makeMethod = (method, defaults) => {
     return async (url, options = {}) => {
@@ -298,7 +271,7 @@ const makeMethod = (method, defaults) => {
             responseFormat,
             includeRaw: merged.includeRaw ?? false,
             timeout: merged.timeout ?? 20000,
-            retry: merged.retry ?? 0,
+            retry: merged.retry,
             stringifyJson,
             fetch: fetcher,
             requestInit: {
@@ -315,33 +288,47 @@ const makeMethod = (method, defaults) => {
                 window: merged.window
             }
         };
-        const onRequest = options.onRequest ?? defaults.onRequest;
-        if (onRequest) {
-            await onRequest(normalizedRequest);
+        // Snapshot the policy per call: hooks and concurrent requests cannot extend its budget.
+        const policy = merged.retry;
+        const limit = policy?.limit ?? 0;
+        if (!Number.isSafeInteger(limit) || limit < 0) {
+            throw new RangeError('retry.limit must be a non-negative safe integer');
         }
-        const doFetch = merged.doFetch ?? defaults.doFetch ?? defaultDoFetch;
-        try {
-            const fetched = await doFetch(normalizedRequest);
-            const onResponse = options.onResponse ?? defaults.onResponse;
-            if (onResponse) {
-                await onResponse(fetched);
+        const statuses = policy?.statuses ? [...policy.statuses] : undefined;
+        const shouldRetry = policy?.shouldRetry;
+        const doFetch = merged.doFetch ?? defaultDoFetch;
+        let fetched;
+        for (let attempt = 0;; attempt++) {
+            normalizedRequest.requestInit.signal?.throwIfAborted();
+            // Re-run authentication/header hooks after recovery, without accumulating headers.
+            normalizedRequest.headers = new Headers(headers);
+            await merged.onRequest?.(normalizedRequest);
+            normalizedRequest.requestInit.signal?.throwIfAborted();
+            try {
+                fetched = await doFetch(normalizedRequest);
+                break;
             }
-            return fetched;
-        }
-        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)
+            catch (error) {
+                const normalizedError = error instanceof HttpServiceError
+                    ? error
+                    : new HttpServiceError({
+                        message: normalizeUnknownError(error).message,
+                        original: normalizeUnknownError(error)
+                    });
+                const aborted = normalizedRequest.requestInit.signal?.aborted || normalizedError.original?.name === 'AbortError';
+                const streaming = typeof ReadableStream !== 'undefined' && normalizedRequest.body instanceof ReadableStream;
+                const eligible = !aborted && !streaming && attempt < limit && (!statuses || statuses.includes(normalizedError.status));
+                if (eligible && (!shouldRetry || (await shouldRetry({ error: normalizedError })))) {
+                    normalizedRequest.requestInit.signal?.throwIfAborted();
+                    continue;
+                }
+                await merged.onError?.(normalizedError, normalizedRequest);
                 throw normalizedError;
-            await onError(normalizedError, normalizedRequest);
-            throw normalizedError;
+            }
         }
+        // Consumer callback failures must never replay a successful HTTP operation.
+        await merged.onResponse?.(fetched);
+        return fetched;
     };
 };
 export class HttpServiceInstance {

package/dist/infra/index.d.ts

@@ -1,5 +1,5 @@
 export { BaseHttpDatasource, type CreateRequestCallbackType } from './datasource/index.js';
 export { DTOMapper, type IDTOMapper } from './resource/index.js';
-export { HttpStatusCode, HttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type IHttpInstanceNormalizedRequest, type IHttpInstanceOnRequest, type IHttpInstanceOnError, type IHttpInstanceDoFetch, type IHttpInstanceRequestMethod } from './http-service/index.js';
+export { HttpStatusCode, HttpServiceInstance, HttpInstanceFetchMethods, HttpErrorTypes, HttpServiceResponse, HttpServiceError, type IHttpServiceError, type IHttpServiceResponse, type IHttpServiceInstance, type IHttpInstanceOptions, type IHttpInstanceRetryOptions, type IHttpInstanceNormalizedRequest, type IHttpInstanceOnRequest, type IHttpInstanceOnError, type IHttpInstanceDoFetch, type IHttpInstanceRequestMethod } from './http-service/index.js';
 export { ResponseBuilder } from './response/index.js';
 export { QueryBuilder, type IQueryBuilderInstance, type ArrayFormat, type ObjectFormat, type IQueryBuilderSettings } from './query/QueryBuilder.js';

package/dist/shared/app/App.d.ts

@@ -1,7 +1,5 @@
 import { type TranslationManagerSource } from '../../i18n/Internal.js';
 import { type ContextData } from '../../shared/request-context/Internal.js';
-import { AppError, type IAppError } from '../app-error/AppError.js';
-import { type AsyncHelperRetry } from '../app-error/ErrorRuntime.js';
 import { type ServerMiddlewareClass } from './middleware/ServerMiddleware.js';
 import type { Handle, HandleFetch, HandleServerError, HandleClientError, Reroute, ServerInit, Transport } from '@sveltejs/kit/hooks';
 import type { RequestEvent } from '@sveltejs/kit';
@@ -10,15 +8,9 @@ import { useLogger } from '../logger/index.js';
 type MaybePromise<T> = T | Promise<T>;
 type HandleInput = Parameters<Handle>[0];
 type Resolve = HandleInput['resolve'];
-type BuilderFlags = Partial<Record<'useTranslations' | 'useBoot' | 'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError' | 'useServerFetch' | 'useAzureNetKitError' | 'useReroute' | 'useTransport', true>>;
+type BuilderFlags = Partial<Record<'useTranslations' | 'useBoot' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError' | 'useServerFetch' | 'useReroute' | 'useTransport', true>>;
 type WithFlag<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags> = TFlags & Record<TKey, true>;
 type OnceMethod<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags, TMethod> = TFlags[TKey] extends true ? object : TMethod;
-export interface AppUniversalLifecycleContext {
-    isClient: boolean;
-    isServer: boolean;
-    requestContext?: ContextData;
-    event?: RequestEvent;
-}
 export interface AppClientLifecycleContext {
     useMiddlewares: (middlewares: readonly ClientMiddlewareClass[]) => void;
 }
@@ -38,15 +30,6 @@ export type AppServerErrorContext = Parameters<HandleServerError>[0] & {
 export type AppServerFetchContext = Parameters<HandleFetch>[0] & {
     requestContext: ContextData;
 };
-export interface AppAzureNetKitErrorContext {
-    error: AppError;
-    retry: AsyncHelperRetry;
-    isClient: boolean;
-    isServer: boolean;
-    requestContext?: ContextData;
-    event?: RequestEvent;
-}
-export type AppUniversalLifecycleCallback = (context: AppUniversalLifecycleContext) => MaybePromise<void>;
 export type AppClientLifecycleCallback = (context: AppClientLifecycleContext) => MaybePromise<void>;
 export type AppClientInitLifecycleCallback = (context: AppClientInitLifecycleContext) => MaybePromise<void>;
 export type AppClientErrorCallback = (context: AppClientErrorContext) => ReturnType<HandleClientError>;
@@ -54,7 +37,6 @@ export type AppServerInitLifecycleCallback = ServerInit;
 export type AppServerLifecycleCallback = (context: AppServerLifecycleContext) => MaybePromise<Response | void>;
 export type AppServerErrorCallback = (context: AppServerErrorContext) => ReturnType<HandleServerError>;
 export type AppServerFetchCallback = (context: AppServerFetchContext) => ReturnType<HandleFetch>;
-export type AppAzureNetKitErrorCallback = (context: AppAzureNetKitErrorContext) => MaybePromise<IAppError & object>;
 export type AppRerouteCallback = Reroute;
 export interface AppBootContext {
     state: App.RequestContextState;
@@ -64,8 +46,6 @@ export type CreateAppBuilder<TFlags extends BuilderFlags = object> = OnceMethod<
     useBoot(callback: AppBootCallback): CreateAppBuilder<WithFlag<TFlags, 'useBoot'>>;
 }> & OnceMethod<TFlags, 'useTranslations', {
     useTranslations(manager: TranslationManagerSource): CreateAppBuilder<WithFlag<TFlags, 'useTranslations'>>;
-}> & OnceMethod<TFlags, 'use', {
-    use(callback: AppUniversalLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'use'>>;
 }> & OnceMethod<TFlags, 'useClient', {
     useClient(callback: AppClientLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useClient'>>;
 }> & OnceMethod<TFlags, 'useClientInit', {
@@ -80,8 +60,6 @@ export type CreateAppBuilder<TFlags extends BuilderFlags = object> = OnceMethod<
     useServerError(callback: AppServerErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerError'>>;
 }> & OnceMethod<TFlags, 'useServerFetch', {
     useServerFetch(callback: AppServerFetchCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerFetch'>>;
-}> & OnceMethod<TFlags, 'useAzureNetKitError', {
-    useAzureNetKitError(callback: AppAzureNetKitErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useAzureNetKitError'>>;
 }> & OnceMethod<TFlags, 'useReroute', {
     useReroute(callback: AppRerouteCallback): CreateAppBuilder<WithFlag<TFlags, 'useReroute'>>;
 }> & OnceMethod<TFlags, 'useTransport', {

package/dist/shared/app/App.js

@@ -3,8 +3,7 @@ import { hydratable } from 'svelte';
 import { getContextInternals } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
 import { RequestContext } from '../../shared/request-context/Internal.js';
-import { AppError, AzureNetKitInternalError } from '../app-error/AppError.js';
-import { bindAzureNetKitErrorResolver } from '../app-error/ErrorRuntime.js';
+import { AzureNetKitInternalError } from '../app-error/AppError.js';
 import { executeServerMiddlewares } from './middleware/ServerMiddleware.js';
 import { beforeNavigate } from '$app/navigation';
 import { executeClientMiddlewares } from './middleware/ClientMiddleware.js';
@@ -61,10 +60,6 @@ const createBuilder = (callbacks) => {
             setCallback(callbacks, 'useBoot', callback);
             return builder;
         },
-        use(callback) {
-            setCallback(callbacks, 'use', callback);
-            return builder;
-        },
         useClient(callback) {
             setCallback(callbacks, 'useClient', callback);
             return builder;
@@ -93,10 +88,6 @@ const createBuilder = (callbacks) => {
             setCallback(callbacks, 'useServerFetch', callback);
             return builder;
         },
-        useAzureNetKitError(callback) {
-            setCallback(callbacks, 'useAzureNetKitError', callback);
-            return builder;
-        },
         useReroute(callback) {
             setCallback(callbacks, 'useReroute', callback);
             return builder;
@@ -115,42 +106,15 @@ export const createApp = (callback) => {
     let translationInitPromise;
     let serverInitPromise;
     callback(createBuilder(callbacks));
-    const errorResolver = callbacks.useAzureNetKitError
-        ? (error, retry) => {
-            const requestContext = BROWSER ? undefined : getRequestContext();
-            return callbacks.useAzureNetKitError({
-                error,
-                retry,
-                isClient: BROWSER,
-                isServer: !BROWSER,
-                requestContext,
-                event: requestContext?.event
-            });
-        }
-        : undefined;
-    const bindErrorResolver = (requestContext) => {
-        bindAzureNetKitErrorResolver(errorResolver, requestContext);
-    };
     const runClient = (kind) => {
         if (!BROWSER)
             return undefined;
-        bindErrorResolver();
         const flags = getLifecycleFlags(appKey);
         if (flags[kind])
             return kind === 'clientInit' ? translationInitPromise : undefined;
         flags[kind] = true;
         if (kind === 'clientInit') {
-            const initialize = () => {
-                const universalContext = {
-                    isClient: true,
-                    isServer: false
-                };
-                const universalResult = callbacks.use?.(universalContext);
-                if (universalResult && typeof universalResult.then === 'function') {
-                    return universalResult.then(() => callbacks.useClientInit?.());
-                }
-                return callbacks.useClientInit?.();
-            };
+            const initialize = () => callbacks.useClientInit?.();
             if (!callbacks.useTranslations)
                 return initialize();
             translationInitPromise = getTranslationManagerLifecycle(callbacks.useTranslations)
@@ -185,29 +149,11 @@ export const createApp = (callback) => {
     const runServerError = (input) => {
         if (BROWSER)
             return undefined;
-        const requestContext = getServerRequestContext();
-        bindErrorResolver(requestContext);
-        try {
-            const result = callbacks.useServerError?.({
-                requestContext,
-                ...input,
-                useLogger
-            });
-            if (result && typeof result.then === 'function') {
-                return Promise.resolve(result).finally(() => bindAzureNetKitErrorResolver(undefined, requestContext));
-            }
-            bindAzureNetKitErrorResolver(undefined, requestContext);
-            return result;
-        }
-        catch (error) {
-            bindAzureNetKitErrorResolver(undefined, requestContext);
-            throw error;
-        }
+        return callbacks.useServerError?.({ requestContext: getServerRequestContext(), ...input, useLogger });
     };
     const runClientError = (input) => {
         if (!BROWSER)
             return undefined;
-        bindErrorResolver();
         return callbacks.useClientError?.({
             ...input
         });
@@ -230,36 +176,21 @@ export const createApp = (callback) => {
             })
             : originalResolve;
         const requestContext = getServerRequestContext();
-        bindErrorResolver(requestContext);
-        try {
-            const flags = getLifecycleFlags(appKey, requestContext);
-            if (!flags.server) {
-                flags.server = true;
-                if (translations)
-                    await translations.preloadTranslation();
-                const universalResult = callbacks.use?.({
-                    isClient: false,
-                    isServer: true,
-                    requestContext,
-                    event
-                });
-                if (universalResult && typeof universalResult.then === 'function') {
-                    await universalResult;
-                }
-                const serverResult = await callbacks.useServer?.({
-                    requestContext,
-                    event,
-                    resolve,
-                    useMiddlewares: executeServerMiddlewares
-                });
-                if (serverResult)
-                    return serverResult;
-            }
-            return await resolve(event);
-        }
-        finally {
-            bindAzureNetKitErrorResolver(undefined, requestContext);
+        const flags = getLifecycleFlags(appKey, requestContext);
+        if (!flags.server) {
+            flags.server = true;
+            if (translations)
+                await translations.preloadTranslation();
+            const serverResult = await callbacks.useServer?.({
+                requestContext,
+                event,
+                resolve,
+                useMiddlewares: executeServerMiddlewares
+            });
+            if (serverResult)
+                return serverResult;
         }
+        return await resolve(event);
     };
     const runBoot = () => {
         if (!callbacks.useBoot && !callbacks.useTranslations)

package/dist/shared/app/index.d.ts

@@ -1,4 +1,4 @@
-export { createApp, type AppAzureNetKitErrorCallback, type AppAzureNetKitErrorContext, type AppClientErrorCallback, type AppClientErrorContext, type AppClientInitLifecycleCallback, type AppClientInitLifecycleContext, type AppClientLifecycleCallback, type AppClientLifecycleContext, type AppRegistrar, type AppServerErrorCallback, type AppServerErrorContext, type AppServerFetchCallback, type AppServerFetchContext, type AppServerInitLifecycleCallback, type AppServerInitLifecycleContext, type AppServerLifecycleCallback, type AppServerLifecycleContext, type AppRerouteCallback, type AppUniversalLifecycleCallback, type AppUniversalLifecycleContext, type CreateAppInstance } from './App.js';
+export { createApp, type AppClientErrorCallback, type AppClientErrorContext, type AppClientInitLifecycleCallback, type AppClientInitLifecycleContext, type AppClientLifecycleCallback, type AppClientLifecycleContext, type AppRegistrar, type AppServerErrorCallback, type AppServerErrorContext, type AppServerFetchCallback, type AppServerFetchContext, type AppServerInitLifecycleCallback, type AppServerInitLifecycleContext, type AppServerLifecycleCallback, type AppServerLifecycleContext, type AppRerouteCallback, type CreateAppInstance } from './App.js';
 export type { IClientMiddleware, ClientMiddlewareContext, ClientMiddlewareClass } from './middleware/ClientMiddleware.js';
 export type { IServerMiddleware, ServerMiddlewareContext, ServerMiddlewareClass } from './middleware/ServerMiddleware.js';
 export type { IMiddleware, MiddlewareClass } from './middleware/Types.js';

package/dist/shared/app-error/AppError.d.ts

@@ -17,6 +17,7 @@ export interface IAppError<T = unknown> {
     validation?: RequestErrors<T>;
     external: boolean;
     appErrorConvert?: boolean;
+    statusCode: number;
 }
 export declare class AppError<T = unknown> extends Error {
     error: Error;
@@ -24,6 +25,7 @@ export declare class AppError<T = unknown> extends Error {
     message: string;
     external: boolean;
     validation?: RequestErrors<T>;
+    statusCode: number;
     constructor(error: Error);
     tryToGetExternalError<HttpServiceDataType = unknown>(): HttpServiceError<HttpServiceDataType> | undefined;
     redeclareValidation<D = T>(validation: D): void;

package/dist/shared/app-error/AppError.js

@@ -18,6 +18,7 @@ export class AppError extends Error {
     message;
     external = false;
     validation;
+    statusCode = 500;
     constructor(error) {
         super(error.message);
         this.error = error;
@@ -41,6 +42,7 @@ export class AppError extends Error {
             external: this.external,
             validation: this.validation,
             appErrorConvert: true,
+            statusCode: this.statusCode,
             ...customData
         };
     }
@@ -49,10 +51,12 @@ export class AppError extends Error {
             case this.error instanceof HttpServiceError:
                 this.type = ErrorTypes.Http;
                 this.external = this.error.type === HttpErrorTypes.External;
+                this.statusCode = this.error.status;
                 break;
             case this.error instanceof SchemaFail:
                 this.type = ErrorTypes.Schema;
                 this.validation = this.error.getSelfTypedData();
+                this.statusCode = 422;
                 break;
             case this.error instanceof AzureNetKitInternalError:
                 this.type = ErrorTypes.KitInternalError;

package/dist/shared/app-error/index.d.ts

@@ -1,2 +1 @@
 export * from './AppError.js';
-export * from './ErrorRuntime.js';

package/dist/shared/app-error/index.js

@@ -1,2 +1 @@
 export * from './AppError.js';
-export * from './ErrorRuntime.js';

package/dist/shared/boundary-provider/CompositionRoot.js

@@ -1,5 +1,5 @@
 import { CreateServiceContainer } from './Provider.js';
-const toProvider = (dependency) => typeof dependency === 'function' ? dependency : dependency.resolve;
+const toProvider = (dependency) => (typeof dependency === 'function' ? dependency : dependency.resolve);
 /** Holds registration metadata only. Resolving always uses the current request's container. */
 export class CompositionRoot {
     name = Symbol('@azure-net/kit:CompositionRoot');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/kit",
-  "version": "6.0.0-next.10",
+  "version": "6.0.0-next.12",
   "license": "MIT",
   "author": "Pixel1917",
   "description": "Universal toolkit and library collection, developed as part of the Azure-net ecosystem",

package/dist/shared/app-error/ErrorRuntime.d.ts

@@ -1,11 +0,0 @@
-import { type ContextData } from '../../shared/request-context/Internal.js';
-import { AppError, type IAppError } from './AppError.js';
-type MaybePromise<T> = T | Promise<T>;
-export interface AsyncHelperRetry {
-    can: boolean;
-    call?: () => Promise<Error | void>;
-}
-export type AzureNetKitErrorResolver = (error: AppError, retry: AsyncHelperRetry) => MaybePromise<IAppError & object>;
-export declare const bindAzureNetKitErrorResolver: (resolver?: AzureNetKitErrorResolver, requestContext?: ContextData) => void;
-export declare const resolveAzureNetKitError: <Validation = unknown, CustomData extends object = Record<never, never>>(error: unknown, retry?: AsyncHelperRetry) => Promise<IAppError<Validation> & CustomData>;
-export {};

package/dist/shared/app-error/ErrorRuntime.js

@@ -1,58 +0,0 @@
-import { getContextInternals } from '../../shared/request-context/Internal.js';
-import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../shared/request-context/Internal.js';
-import { AppError, AzureNetKitInternalError } from './AppError.js';
-const SERVER_BINDING_KEY = Symbol('azureNetKitErrorResolver');
-let clientBinding;
-const createBinding = (resolver) => ({ resolver });
-const getServerData = (requestContext) => {
-    if (requestContext)
-        return getContextInternals(requestContext);
-    try {
-        return getContextInternals(RequestContext.current());
-    }
-    catch {
-        return undefined;
-    }
-};
-export const bindAzureNetKitErrorResolver = (resolver, requestContext) => {
-    if (BROWSER) {
-        clientBinding = resolver ? createBinding(resolver) : undefined;
-        return;
-    }
-    const data = getServerData(requestContext);
-    if (!data)
-        return;
-    if (resolver) {
-        data[SERVER_BINDING_KEY] = createBinding(resolver);
-    }
-    else {
-        delete data[SERVER_BINDING_KEY];
-    }
-};
-const getBinding = () => {
-    if (BROWSER)
-        return clientBinding;
-    return getServerData()?.[SERVER_BINDING_KEY];
-};
-const normalizeError = (error) => (error instanceof Error ? error : new Error(String(error)));
-export const resolveAzureNetKitError = async (error, retry = { can: false }) => {
-    const normalizedError = normalizeError(error);
-    const appError = normalizedError instanceof AppError ? normalizedError : new AppError(normalizedError);
-    const binding = getBinding();
-    if (!binding || binding.activeErrors?.has(normalizedError)) {
-        return appError.toPlainObject();
-    }
-    const activeErrors = (binding.activeErrors ??= new WeakSet());
-    activeErrors.add(normalizedError);
-    try {
-        const result = await binding.resolver(appError, retry);
-        if (!result?.appErrorConvert) {
-            throw new AzureNetKitInternalError("[createApp] 'useAzureNetKitError' must return the result of AppError.toPlainObject().");
-        }
-        return result;
-    }
-    finally {
-        activeErrors.delete(normalizedError);
-    }
-};