@azure-net/kit 6.0.0-next.15 → 6.0.0-next.17

package/README.md

@@ -79,8 +79,8 @@ export const useOrdersPresenter = RegisterProvider(
 		const { Orders } = ApplicationProvider();
 		return new OrdersPresenter(Orders);
 	},
-	{ lifecycle: 'scoped', bindMethods: true }
-);
+	{ lifecycle: 'scoped', bindMethods: true };
+});
 ```
 
 Call `useOrdersPresenter()` during component initialization, not at module scope.
@@ -192,18 +192,23 @@ export {};
 import { createApp, ServerMiddlewareManager } from '@azure-net/kit';
 import { RequestContext } from '@azure-net/kit/server-context';
 
-export const { register } = createApp((app) =>
-	app
-		.useServer(async ({ event, resolve }) => {
+export const { register } = createApp((app) => {
+ app.useServer(async ({ event, resolve }) => {
 			await new ServerMiddlewareManager([ServerAuth]).execute();
 			return resolve(event);
-		})
-		.useBoot(({ state }) => {
+		});
+ app.useBoot(({ state }) => {
 			useCurrentUser().setUser(state.currentUser ?? null);
 		})
 );
 ```
 
+The configuration callback is synchronous. Each `app.useX(...)` returns `void`;
+register hooks with separate statements, without chaining or `return app`.
+Duplicate registrations and registrations after the callback completes throw.
+Hook execution still follows the framework lifecycle, not registration order.
+Hooks that support async work keep their existing async contracts.
+
 In the root layout call `register()` before resolving presenters or state classes.
 `useBoot` is synchronous and runs once per server request render and once per
 browser app initialization, before client lifecycle callbacks. Await all server
@@ -285,9 +290,11 @@ to override the public response, or return nothing to retain SvelteKit defaults.
 The removed `handleValidationError` hook is not generated.
 
 ```ts
-app.useServerError(({ kind, error, useLogger }) => {
+import { RemoteLogger } from '@azure-net/kit';
+
+app.useServerError(({ kind, error }) => {
 	if (kind === 'unknown') {
-		useLogger(error, {});
+		RemoteLogger.log(error, {});
 		return { status: 500, message: 'Internal Error' };
 	}
 	return error;

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

@@ -2,13 +2,9 @@ import { type TranslationManagerSource } from '../../i18n/Internal.js';
 import { type ContextData } from '../../shared/request-context/Internal.js';
 import type { Handle, HandleFetch, HandleServerError, HandleClientError, Reroute, ServerInit, Transport } from '@sveltejs/kit/hooks';
 import type { RequestEvent } from '@sveltejs/kit';
-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' | '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 type AppClientLifecycleContext = void;
 export type AppClientInitLifecycleContext = void;
 export type AppClientErrorContext = Parameters<HandleClientError>[0];
@@ -20,7 +16,6 @@ export interface AppServerLifecycleContext {
 }
 export type AppServerErrorContext = Parameters<HandleServerError>[0] & {
     requestContext: ContextData;
-    useLogger: typeof useLogger;
 };
 export type AppServerFetchContext = Parameters<HandleFetch>[0] & {
     requestContext: ContextData;
@@ -37,29 +32,19 @@ export interface AppBootContext {
     state: App.RequestContextState;
 }
 export type AppBootCallback = (context: AppBootContext) => undefined;
-export type CreateAppBuilder<TFlags extends BuilderFlags = object> = OnceMethod<TFlags, 'useBoot', {
-    useBoot(callback: AppBootCallback): CreateAppBuilder<WithFlag<TFlags, 'useBoot'>>;
-}> & OnceMethod<TFlags, 'useTranslations', {
-    useTranslations(manager: TranslationManagerSource): CreateAppBuilder<WithFlag<TFlags, 'useTranslations'>>;
-}> & OnceMethod<TFlags, 'useClient', {
-    useClient(callback: AppClientLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useClient'>>;
-}> & OnceMethod<TFlags, 'useClientInit', {
-    useClientInit(callback: AppClientInitLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useClientInit'>>;
-}> & OnceMethod<TFlags, 'useClientError', {
-    useClientError(callback: AppClientErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useClientError'>>;
-}> & OnceMethod<TFlags, 'useServerInit', {
-    useServerInit(callback: AppServerInitLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerInit'>>;
-}> & OnceMethod<TFlags, 'useServer', {
-    useServer(callback: AppServerLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useServer'>>;
-}> & OnceMethod<TFlags, 'useServerError', {
-    useServerError(callback: AppServerErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerError'>>;
-}> & OnceMethod<TFlags, 'useServerFetch', {
-    useServerFetch(callback: AppServerFetchCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerFetch'>>;
-}> & OnceMethod<TFlags, 'useReroute', {
-    useReroute(callback: AppRerouteCallback): CreateAppBuilder<WithFlag<TFlags, 'useReroute'>>;
-}> & OnceMethod<TFlags, 'useTransport', {
-    useTransport(transport: Transport): CreateAppBuilder<WithFlag<TFlags, 'useTransport'>>;
-}>;
+export interface AppConfiguration {
+    useTranslations(manager: TranslationManagerSource): void;
+    useBoot(callback: AppBootCallback): void;
+    useClient(callback: AppClientLifecycleCallback): void;
+    useClientInit(callback: AppClientInitLifecycleCallback): void;
+    useClientError(callback: AppClientErrorCallback): void;
+    useServerInit(callback: AppServerInitLifecycleCallback): void;
+    useServer(callback: AppServerLifecycleCallback): void;
+    useServerError(callback: AppServerErrorCallback): void;
+    useServerFetch(callback: AppServerFetchCallback): void;
+    useReroute(callback: AppRerouteCallback): void;
+    useTransport(transport: Transport): void;
+}
 export interface AppRegistrar {
     (): MaybePromise<void>;
     clientInit(): MaybePromise<void>;
@@ -74,5 +59,5 @@ export interface AppRegistrar {
 export interface CreateAppInstance {
     register: AppRegistrar;
 }
-export declare const createApp: (callback: (app: CreateAppBuilder) => unknown) => CreateAppInstance;
+export declare const createApp: (callback: (app: AppConfiguration) => void) => CreateAppInstance;
 export {};

package/dist/shared/app/App.js

@@ -4,7 +4,6 @@ import { getContextInternals } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
 import { RequestContext } from '../../shared/request-context/Internal.js';
 import { AzureNetKitInternalError } from '../app-error/AppError.js';
-import { useLogger } from '../logger/index.js';
 const clientLifecycleFlags = new WeakMap();
 const getRequestContext = () => {
     try {
@@ -41,67 +40,45 @@ const getLifecycleFlags = (appKey, requestContext) => {
     }
     return flags;
 };
-const setCallback = (callbacks, key, callback) => {
-    if (callbacks[key]) {
-        throw new AzureNetKitInternalError(`[createApp] '${key}' can be registered only once.`);
-    }
-    callbacks[key] = callback;
-};
-const createBuilder = (callbacks) => {
-    const builder = {
-        useTranslations(manager) {
-            setCallback(callbacks, 'useTranslations', manager);
-            return builder;
-        },
-        useBoot(callback) {
-            setCallback(callbacks, 'useBoot', callback);
-            return builder;
-        },
-        useClient(callback) {
-            setCallback(callbacks, 'useClient', callback);
-            return builder;
-        },
-        useClientInit(callback) {
-            setCallback(callbacks, 'useClientInit', callback);
-            return builder;
-        },
-        useClientError(callback) {
-            setCallback(callbacks, 'useClientError', callback);
-            return builder;
-        },
-        useServerInit(callback) {
-            setCallback(callbacks, 'useServerInit', callback);
-            return builder;
-        },
-        useServer(callback) {
-            setCallback(callbacks, 'useServer', callback);
-            return builder;
-        },
-        useServerError(callback) {
-            setCallback(callbacks, 'useServerError', callback);
-            return builder;
-        },
-        useServerFetch(callback) {
-            setCallback(callbacks, 'useServerFetch', callback);
-            return builder;
-        },
-        useReroute(callback) {
-            setCallback(callbacks, 'useReroute', callback);
-            return builder;
-        },
-        useTransport(transport) {
-            setCallback(callbacks, 'useTransport', transport);
-            return builder;
-        }
+const configureApp = (callbacks, configure) => {
+    let open = true;
+    const set = (key, value) => {
+        if (!open)
+            throw new AzureNetKitInternalError('[createApp] Configuration is closed. Register hooks synchronously inside createApp.');
+        if (Object.hasOwn(callbacks, key))
+            throw new AzureNetKitInternalError(`[createApp] '${key}' can be registered only once.`);
+        callbacks[key] = value;
     };
-    return builder;
+    const app = {
+        useTranslations: (value) => set('useTranslations', value),
+        useBoot: (value) => set('useBoot', value),
+        useClient: (value) => set('useClient', value),
+        useClientInit: (value) => set('useClientInit', value),
+        useClientError: (value) => set('useClientError', value),
+        useServerInit: (value) => set('useServerInit', value),
+        useServer: (value) => set('useServer', value),
+        useServerError: (value) => set('useServerError', value),
+        useServerFetch: (value) => set('useServerFetch', value),
+        useReroute: (value) => set('useReroute', value),
+        useTransport: (value) => set('useTransport', value)
+    };
+    try {
+        const result = configure(app);
+        if (result && typeof result.then === 'function') {
+            void Promise.resolve(result).catch(() => undefined);
+            throw new AzureNetKitInternalError('[createApp] Configuration must be synchronous.');
+        }
+    }
+    finally {
+        open = false;
+    }
 };
 export const createApp = (callback) => {
     const appKey = {};
     const callbacks = {};
     let translationInitPromise;
     let serverInitPromise;
-    callback(createBuilder(callbacks));
+    configureApp(callbacks, callback);
     const runClient = (kind) => {
         if (!BROWSER)
             return undefined;
@@ -134,7 +111,7 @@ export const createApp = (callback) => {
     const runServerError = (input) => {
         if (BROWSER)
             return undefined;
-        return callbacks.useServerError?.({ requestContext: getServerRequestContext(), ...input, useLogger });
+        return callbacks.useServerError?.({ requestContext: getServerRequestContext(), ...input });
     };
     const runClientError = (input) => {
         if (!BROWSER)

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

@@ -1,4 +1,4 @@
-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 { createApp, type AppClientErrorCallback, type AppClientErrorContext, type AppClientInitLifecycleCallback, type AppClientInitLifecycleContext, type AppClientLifecycleCallback, type AppClientLifecycleContext, type AppRegistrar, type AppConfiguration, 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 { ClientMiddlewareManager } from './middleware/ClientMiddleware.js';
 export type { IServerMiddleware, ServerMiddlewareContext, ServerMiddlewareClass } from './middleware/ServerMiddleware.js';

package/dist/shared/app/middleware/ClientMiddleware.d.ts

@@ -6,6 +6,7 @@ export interface ClientMiddlewareContext {
     to: ReadonlyURL;
     from?: ReadonlyURL;
     navigation?: BeforeNavigate;
+    byRedirect?: boolean;
     next: (location?: string | URL, options?: GotoOptions) => undefined;
     ensureRoute: EnsureRoute;
 }

package/dist/shared/app/middleware/ClientMiddleware.js

@@ -36,6 +36,7 @@ export const executeClientMiddlewares = (middlewares, navigation) => {
             result = new middleware().execute({
                 to,
                 from,
+                byRedirect: !!navigation,
                 next,
                 ensureRoute,
                 navigation

package/dist/shared/app/middleware/ServerMiddleware.d.ts

@@ -5,6 +5,7 @@ import type { IMiddleware, MiddlewareClass } from './Types.js';
 export interface ServerMiddlewareContext {
     to: RequestEvent['url'];
     from?: RequestEvent['url'];
+    byRedirect: boolean;
     next: (location?: string | URL, status?: RedirectStatus) => void;
     event: RequestEvent;
     ensureRoute: EnsureRoute;
@@ -17,6 +18,6 @@ export type ServerMiddlewareClass = MiddlewareClass<IServerMiddleware>;
 export declare class ServerMiddlewareManager {
     private readonly middlewares;
     constructor(middlewares: readonly ServerMiddlewareClass[]);
-    execute(): Promise<void>;
+    execute(byRedirect?: boolean): Promise<void>;
 }
-export declare const executeServerMiddlewares: (middlewares: readonly ServerMiddlewareClass[]) => Promise<void>;
+export declare const executeServerMiddlewares: (middlewares: readonly ServerMiddlewareClass[], byRedirect?: boolean) => Promise<void>;

package/dist/shared/app/middleware/ServerMiddleware.js

@@ -8,11 +8,11 @@ export class ServerMiddlewareManager {
     constructor(middlewares) {
         this.middlewares = [...middlewares];
     }
-    execute() {
-        return executeServerMiddlewares(this.middlewares);
+    execute(byRedirect = true) {
+        return executeServerMiddlewares(this.middlewares, byRedirect);
     }
 }
-export const executeServerMiddlewares = async (middlewares) => {
+export const executeServerMiddlewares = async (middlewares, byRedirect = true) => {
     if (!BROWSER && middlewares.length) {
         const event = RequestContext.current().event;
         if (event) {
@@ -31,6 +31,7 @@ export const executeServerMiddlewares = async (middlewares) => {
                     event,
                     to,
                     from,
+                    byRedirect,
                     next,
                     ensureRoute
                 });

package/dist/shared/index.d.ts

@@ -4,4 +4,4 @@ export { ClassMirror } from './class-mirror/index.js';
 export { CreateServiceContainer, cleanupProvider, type ProviderSettings, type ProviderKey } from './boundary-provider/index.js';
 export { CompositionRoot, type CompositionRootSettings } from './boundary-provider/index.js';
 export * from './app/index.js';
-export { useLogger, LoggerErrors, type ILoggerError, type ILoggerSettings } from './logger/index.js';
+export { RemoteLogger, LoggerErrors, type ILoggerError, type ILoggerSettings } from './logger/index.js';

package/dist/shared/index.js

@@ -4,4 +4,4 @@ export { ClassMirror } from './class-mirror/index.js';
 export { CreateServiceContainer, cleanupProvider } from './boundary-provider/index.js';
 export { CompositionRoot } from './boundary-provider/index.js';
 export * from './app/index.js';
-export { useLogger, LoggerErrors } from './logger/index.js';
+export { RemoteLogger, LoggerErrors } from './logger/index.js';

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

@@ -21,4 +21,6 @@ export interface ILoggerSettings {
     filterLog?: (error: ILoggerError) => boolean;
     includeOnly?: LoggerErrors[];
 }
-export declare const useLogger: (error: unknown, settings: ILoggerSettings) => BackgroundTask<void>;
+export declare class RemoteLogger {
+    static log(error: unknown, settings: ILoggerSettings): BackgroundTask<void>;
+}

package/dist/shared/logger/index.js

@@ -48,31 +48,33 @@ const getFetcher = () => {
         return fetch;
     }
 };
-export const useLogger = (error, settings) => {
-    const preparedError = prepareError(error);
-    if (settings.filterLog && settings.filterLog(preparedError)) {
-        return BackgroundTask.run(() => undefined);
-    }
-    if (settings.includeOnly && !settings.includeOnly.includes(preparedError.type)) {
-        return BackgroundTask.run(() => undefined);
-    }
-    const prefix = settings?.prefix ?? '[Logger]';
-    const errorMessage = prefix + preparedError.message + (settings?.joinToLog ? settings.joinToLog(preparedError) : '');
-    console.log(errorMessage);
-    if (!settings.collector)
-        return BackgroundTask.run(() => undefined);
-    const { collector } = settings;
-    return BackgroundTask.run(async () => {
-        try {
-            await getFetcher()(collector.request(preparedError));
+export class RemoteLogger {
+    static log(error, settings) {
+        const preparedError = prepareError(error);
+        if (settings.filterLog && settings.filterLog(preparedError)) {
+            return BackgroundTask.run(() => undefined);
+        }
+        if (settings.includeOnly && !settings.includeOnly.includes(preparedError.type)) {
+            return BackgroundTask.run(() => undefined);
         }
-        catch (err) {
+        const prefix = settings?.prefix ?? '[Logger]';
+        const errorMessage = prefix + preparedError.message + (settings?.joinToLog ? settings.joinToLog(preparedError) : '');
+        console.log(errorMessage);
+        if (!settings.collector)
+            return BackgroundTask.run(() => undefined);
+        const { collector } = settings;
+        return BackgroundTask.run(async () => {
             try {
-                collector.onError?.(err);
+                await getFetcher()(collector.request(preparedError));
             }
-            catch {
-                return;
+            catch (err) {
+                try {
+                    collector.onError?.(err);
+                }
+                catch {
+                    return;
+                }
             }
-        }
-    });
-};
+        });
+    }
+}

package/package.json

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