@azure-net/kit 5.0.0 → 5.0.1

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

@@ -213,7 +213,7 @@ const parseResponse = async (response, request) => {
     if (!response.ok || parseError) {
         const message = !response.ok
             ? `Request failed with status code ${response.status}. ${response.statusText}`
-            : (parseError?.message ?? 'Internal error');
+            : (parseError?.message ?? `Internal error. Request failed. ${response?.status ?? ''} ${response?.statusText ?? ''}`);
         throw new HttpServiceError({
             status: response.status,
             data,

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

@@ -2,6 +2,7 @@ import { type ContextData } from '../../external/edges/ServerContext.js';
 import { type IServerMiddleware } from './middleware/ServerMiddleware.js';
 import type { Handle, HandleClientError, HandleServerError, RequestEvent, ServerInit } from '@sveltejs/kit';
 import { type IClientMiddleware } from './middleware/ClientMiddleware.js';
+import { useLogger } from '../logger/index.js';
 type MaybePromise<T> = T | Promise<T>;
 type HandleInput = Parameters<Handle>[0];
 type Resolve = HandleInput['resolve'];
@@ -54,6 +55,7 @@ export interface AppServerErrorContext<TDependencies extends Record<string, unkn
     event: RequestEvent;
     status: number;
     message: string;
+    useLogger: typeof useLogger;
 }
 export type AppUniversalLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppUniversalLifecycleContext<TDependencies>) => MaybePromise<void>;
 export type AppClientLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppClientLifecycleContext<TDependencies>) => MaybePromise<void>;

package/dist/shared/app/App.js

@@ -5,6 +5,7 @@ import { AzureNetKitInternalError } from '../app-error/AppError.js';
 import { executeServerMiddlewares } from './middleware/ServerMiddleware.js';
 import { beforeNavigate } from '$app/navigation';
 import { executeClientMiddlewares } from './middleware/ClientMiddleware.js';
+import { useLogger } from '../logger/index.js';
 const DEFAULT_APP_NAME = '__AzureNetKitGlobalAppContainer__';
 const clientLifecycleFlags = new WeakMap();
 const serverInitLifecycleFlags = new WeakMap();
@@ -189,7 +190,8 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             error,
             event,
             status,
-            message
+            message,
+            useLogger
         });
     };
     const runClientError = ({ error, event, status, message }) => {

package/dist/shared/index.d.ts

@@ -3,3 +3,4 @@ export { AppEvents } from './event-bus/index.js';
 export { ClassMirror } from './class-mirror/index.js';
 export { createBoundaryProvider, cleanupProvider, type ProviderSettings } from './boundary-provider/index.js';
 export { createApp, type AppContainer, type CreateAppInstance, type IServerMiddleware, type IClientMiddleware } from './app/index.js';
+export { useLogger, LoggerErrors, type ILoggerError, type ILoggerSettings } from './logger/index.js';

package/dist/shared/index.js

@@ -3,3 +3,4 @@ export { AppEvents } from './event-bus/index.js';
 export { ClassMirror } from './class-mirror/index.js';
 export { createBoundaryProvider, cleanupProvider } from './boundary-provider/index.js';
 export { createApp } from './app/index.js';
+export { useLogger, LoggerErrors } from './logger/index.js';

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

@@ -0,0 +1,23 @@
+import { AppError, type IAppError } from '../app-error/index.js';
+export declare enum LoggerErrors {
+    AzureNetKitInternal = 0,
+    AzureNetAppError = 1,
+    ProjectError = 2,
+    UnknownError = 3
+}
+export interface ILoggerError {
+    message: string;
+    type: LoggerErrors;
+    original: Error | IAppError | AppError;
+}
+export interface ILoggerSettings {
+    collector?: {
+        request: (error: ILoggerError) => Request;
+        onError?: (error: unknown) => void;
+    };
+    prefix?: string;
+    joinToLog?: (error: ILoggerError) => string;
+    filterLog?: (error: ILoggerError) => boolean;
+    includeOnly?: LoggerErrors[];
+}
+export declare const useLogger: (error: unknown, settings: ILoggerSettings) => void;

package/dist/shared/logger/index.js

@@ -0,0 +1,73 @@
+import { AppError, AzureNetKitInternalError } from '../app-error/index.js';
+import { BROWSER } from '../../external/tools/index.js';
+import { RequestContext } from '../../external/edges/ServerContext.js';
+export var LoggerErrors;
+(function (LoggerErrors) {
+    LoggerErrors[LoggerErrors["AzureNetKitInternal"] = 0] = "AzureNetKitInternal";
+    LoggerErrors[LoggerErrors["AzureNetAppError"] = 1] = "AzureNetAppError";
+    LoggerErrors[LoggerErrors["ProjectError"] = 2] = "ProjectError";
+    LoggerErrors[LoggerErrors["UnknownError"] = 3] = "UnknownError";
+})(LoggerErrors || (LoggerErrors = {}));
+const prepareError = (error) => {
+    if (error instanceof AppError || (error && typeof error === 'object' && 'appErrorConvert' in error)) {
+        const typedError = error;
+        return {
+            original: typedError,
+            message: `[AppError ${typedError.type}] ${typedError.message}`,
+            type: LoggerErrors.AzureNetAppError
+        };
+    }
+    if (error instanceof AzureNetKitInternalError) {
+        return {
+            original: error,
+            message: `[AzureNetInternalError] ${error.message}`,
+            type: LoggerErrors.AzureNetKitInternal
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            original: error,
+            message: error.message,
+            type: LoggerErrors.ProjectError
+        };
+    }
+    return {
+        original: new Error('Unknown error occurred'),
+        message: 'Unknown error occurred',
+        type: LoggerErrors.UnknownError
+    };
+};
+const getFetcher = () => {
+    if (BROWSER)
+        return fetch;
+    try {
+        return RequestContext.current()?.event?.fetch ?? fetch;
+    }
+    catch {
+        return fetch;
+    }
+};
+export const useLogger = (error, settings) => {
+    const preparedError = prepareError(error);
+    if (settings.filterLog && settings.filterLog(preparedError)) {
+        return;
+    }
+    if (settings.includeOnly && !settings.includeOnly.includes(preparedError.type)) {
+        return;
+    }
+    const prefix = settings?.prefix ?? '[Logger]';
+    const errorMessage = prefix + preparedError.message + (settings?.joinToLog ? settings.joinToLog(preparedError) : '');
+    console.log(errorMessage);
+    if (settings.collector) {
+        const fetcher = getFetcher();
+        try {
+            void fetcher(settings.collector.request(preparedError)).catch((err) => {
+                settings.collector?.onError?.(err);
+                return;
+            });
+        }
+        catch (err) {
+            settings.collector.onError?.(err);
+        }
+    }
+};

package/package.json

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