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

package/dist/shared/app/App.js

@@ -1,14 +1,14 @@
+import { getTranslationManagerLifecycle } from '../../i18n/Internal.js';
+import { hydratable } from 'svelte';
+import { getContextInternals } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.js';
-import { createBoundaryProvider } from '../boundary-provider/Provider.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 { AppEvents } from '../event-bus/EventBus.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 getRequestContext = () => {
     try {
@@ -37,7 +37,7 @@ const getLifecycleFlags = (appKey, requestContext) => {
     if (!context) {
         throw new AzureNetKitInternalError('[createApp] RequestContext is not initialized on server.');
     }
-    const flagsMap = (context.data.appLifecycleFlags ??= new WeakMap());
+    const flagsMap = (getContextInternals(context).appLifecycleFlags ??= new WeakMap());
     let flags = flagsMap.get(appKey);
     if (!flags) {
         flags = {};
@@ -51,8 +51,16 @@ const setCallback = (callbacks, key, callback) => {
     }
     callbacks[key] = callback;
 };
-const createBuilder = (dependencies, callbacks) => {
+const createBuilder = (callbacks) => {
     const builder = {
+        useTranslations(manager) {
+            setCallback(callbacks, 'useTranslations', manager);
+            return builder;
+        },
+        useBoot(callback) {
+            setCallback(callbacks, 'useBoot', callback);
+            return builder;
+        },
         use(callback) {
             setCallback(callbacks, 'use', callback);
             return builder;
@@ -85,10 +93,6 @@ const createBuilder = (dependencies, callbacks) => {
             setCallback(callbacks, 'useServerFetch', callback);
             return builder;
         },
-        useServerValidationError(callback) {
-            setCallback(callbacks, 'useServerValidationError', callback);
-            return builder;
-        },
         useAzureNetKitError(callback) {
             setCallback(callbacks, 'useAzureNetKitError', callback);
             return builder;
@@ -100,60 +104,21 @@ const createBuilder = (dependencies, callbacks) => {
         useTransport(transport) {
             setCallback(callbacks, 'useTransport', transport);
             return builder;
-        },
-        dependencies(nextDependencies) {
-            for (const [key, factory] of Object.entries(nextDependencies)) {
-                dependencies.set(key, factory);
-            }
-            return builder;
         }
     };
     return builder;
 };
-export const createApp = (callback, name = DEFAULT_APP_NAME) => {
+export const createApp = (callback) => {
     const appKey = {};
-    const dependencies = new Map();
     const callbacks = {};
     let clientInitialized = false;
+    let translationInitPromise;
     let serverInitPromise;
-    callback(createBuilder(dependencies, callbacks));
-    const AppProvider = createBoundaryProvider(name, {
-        register: () => {
-            const factories = {};
-            for (const [key, factory] of dependencies.entries()) {
-                factories[key] = () => factory(Container);
-            }
-            return factories;
-        }
-    });
-    const Container = new Proxy({}, {
-        get(_, key) {
-            if (typeof key === 'symbol')
-                return undefined;
-            return AppProvider()[key];
-        },
-        has(_, key) {
-            return typeof key === 'string' && key in AppProvider();
-        },
-        ownKeys() {
-            return Reflect.ownKeys(AppProvider());
-        },
-        getOwnPropertyDescriptor(_, key) {
-            if (typeof key !== 'string' || !(key in AppProvider()))
-                return undefined;
-            return {
-                configurable: true,
-                enumerable: true,
-                value: AppProvider()[key]
-            };
-        }
-    });
+    callback(createBuilder(callbacks));
     const errorResolver = callbacks.useAzureNetKitError
         ? (error, retry) => {
             const requestContext = BROWSER ? undefined : getRequestContext();
             return callbacks.useAzureNetKitError({
-                Container,
-                AppEvents,
                 error,
                 retry,
                 isClient: BROWSER,
@@ -172,39 +137,44 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
         bindErrorResolver();
         const flags = getLifecycleFlags(appKey);
         if (flags[kind])
-            return undefined;
+            return kind === 'clientInit' ? translationInitPromise : undefined;
         flags[kind] = true;
         if (kind === 'clientInit') {
-            const universalContext = {
-                Container,
-                isClient: true,
-                isServer: false
+            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 universalResult = callbacks.use?.(universalContext);
-            if (universalResult && typeof universalResult.then === 'function') {
-                return universalResult.then(() => callbacks.useClientInit?.({ Container }));
-            }
-            return callbacks.useClientInit?.({ Container });
+            if (!callbacks.useTranslations)
+                return initialize();
+            translationInitPromise = getTranslationManagerLifecycle(callbacks.useTranslations)
+                .initializeClient()
+                .then(initialize)
+                .catch((error) => {
+                delete flags.clientInit;
+                translationInitPromise = undefined;
+                throw error;
+            });
+            return translationInitPromise;
         }
         let internalMiddlewares = [];
-        const clientResult = callbacks.useClient?.({
-            Container,
-            useMiddlewares: (middlewares) => {
-                internalMiddlewares = middlewares;
-            }
-        });
-        const registerNavigation = () => {
-            if (clientInitialized)
-                return;
-            clientInitialized = true;
+        if (!clientInitialized) {
             beforeNavigate((navigation) => {
                 executeClientMiddlewares(internalMiddlewares, navigation);
             });
-        };
-        if (clientResult && typeof clientResult.then === 'function') {
-            return clientResult.then(registerNavigation);
+            clientInitialized = true;
         }
-        registerNavigation();
+        return callbacks.useClient?.({
+            useMiddlewares: (middlewares) => {
+                internalMiddlewares = middlewares;
+            }
+        });
     };
     const runServerInit = () => {
         if (BROWSER)
@@ -212,19 +182,15 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
         serverInitPromise ??= Promise.resolve().then(() => callbacks.useServerInit?.());
         return serverInitPromise;
     };
-    const runServerError = ({ error, event, status, message }) => {
+    const runServerError = (input) => {
         if (BROWSER)
             return undefined;
         const requestContext = getServerRequestContext();
         bindErrorResolver(requestContext);
         try {
             const result = callbacks.useServerError?.({
-                Container,
                 requestContext,
-                error,
-                event,
-                status,
-                message,
+                ...input,
                 useLogger
             });
             if (result && typeof result.then === 'function') {
@@ -238,16 +204,12 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             throw error;
         }
     };
-    const runClientError = ({ error, event, status, message }) => {
+    const runClientError = (input) => {
         if (!BROWSER)
             return undefined;
         bindErrorResolver();
         return callbacks.useClientError?.({
-            Container,
-            error,
-            event,
-            status,
-            message
+            ...input
         });
     };
     const runServerFetch = (input) => {
@@ -255,31 +217,27 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             return input.fetch(input.request);
         return callbacks.useServerFetch({
             ...input,
-            Container,
-            requestContext: getServerRequestContext()
-        });
-    };
-    const runServerValidationError = (input) => {
-        if (!callbacks.useServerValidationError) {
-            console.error('Remote function schema validation failed:', input.issues);
-            return { message: 'Bad Request' };
-        }
-        return callbacks.useServerValidationError({
-            ...input,
-            Container,
             requestContext: getServerRequestContext()
         });
     };
     const reroute = (input) => callbacks.useReroute?.(input);
-    const handle = async ({ event, resolve }) => {
+    const handle = async ({ event, resolve: originalResolve }) => {
+        const translations = callbacks.useTranslations ? getTranslationManagerLifecycle(callbacks.useTranslations) : undefined;
+        const resolve = translations
+            ? (event, options) => originalResolve(event, {
+                ...options,
+                transformPageChunk: async (chunk) => translations.transformHtml((await options?.transformPageChunk?.(chunk)) ?? chunk.html)
+            })
+            : 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?.({
-                    Container,
                     isClient: false,
                     isServer: true,
                     requestContext,
@@ -289,7 +247,6 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
                     await universalResult;
                 }
                 const serverResult = await callbacks.useServer?.({
-                    Container,
                     requestContext,
                     event,
                     resolve,
@@ -304,19 +261,36 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
             bindAzureNetKitErrorResolver(undefined, requestContext);
         }
     };
-    const register = Object.assign(() => runClient('client'), {
+    const runBoot = () => {
+        if (!callbacks.useBoot && !callbacks.useTranslations)
+            return;
+        const flags = getLifecycleFlags(appKey);
+        if (flags.boot)
+            return;
+        flags.boot = true;
+        const state = hydratable('@azure-net/kit:initial-state:v1', () => (BROWSER ? {} : RequestContext.current().state));
+        if (callbacks.useTranslations)
+            getTranslationManagerLifecycle(callbacks.useTranslations).syncFromState(state);
+        const result = callbacks.useBoot?.({ state });
+        if (result && typeof result.then === 'function') {
+            void Promise.resolve(result).catch(() => undefined);
+            throw new AzureNetKitInternalError('[createApp] useBoot must be synchronous.');
+        }
+    };
+    const register = Object.assign(() => {
+        runBoot();
+        return runClient('client');
+    }, {
         clientInit: () => runClient('clientInit'),
         clientError: runClientError,
         serverInit: runServerInit,
         serverError: runServerError,
         serverFetch: runServerFetch,
-        serverValidationError: runServerValidationError,
         handle,
         reroute,
         transport: callbacks.useTransport ?? {}
     });
     return {
-        Container,
         register
     };
 };

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

@@ -1,4 +1,6 @@
-export { createApp, type AppAzureNetKitErrorCallback, type AppAzureNetKitErrorContext, type AppClientErrorCallback, type AppClientErrorContext, type AppClientInitLifecycleCallback, type AppClientInitLifecycleContext, type AppClientLifecycleCallback, type AppClientLifecycleContext, type AppContainer, type AppRegistrar, type AppServerErrorCallback, type AppServerErrorContext, type AppServerFetchCallback, type AppServerFetchContext, type AppServerInitLifecycleCallback, type AppServerInitLifecycleContext, type AppServerLifecycleCallback, type AppServerLifecycleContext, type AppServerValidationErrorCallback, type AppServerValidationErrorContext, type AppRerouteCallback, type AppUniversalLifecycleCallback, type AppUniversalLifecycleContext, type CreateAppInstance } from './App.js';
-export type { IClientMiddleware } from './middleware/ClientMiddleware.js';
-export type { IServerMiddleware } from './middleware/ServerMiddleware.js';
+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 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';
 export type { EnsureRoute, EnsureRouteSource, EnsureRouteTarget } from './middleware/Shared.js';
+export type { AppBootContext, AppBootCallback } from './App.js';

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

@@ -1,10 +1,16 @@
-import { type BeforeNavigate } from '@sveltejs/kit';
 import { type EnsureRoute } from './Shared.js';
-import type { RedirectStatus } from '../../redirect/index.js';
-export type IClientMiddleware = (middlewareData: {
-    to: URL;
-    from?: URL;
-    next: (location?: string | URL, status?: RedirectStatus) => undefined;
+import type { BeforeNavigate, GotoOptions } from '$app/navigation';
+import type { ReadonlyURL } from '$app/state';
+import type { IMiddleware, MiddlewareClass } from './Types.js';
+export interface ClientMiddlewareContext {
+    to: ReadonlyURL;
+    from?: ReadonlyURL;
+    navigation?: BeforeNavigate;
+    next: (location?: string | URL, options?: GotoOptions) => undefined;
     ensureRoute: EnsureRoute;
-}) => undefined;
-export declare const executeClientMiddlewares: (middlewares: IClientMiddleware[], navigation?: BeforeNavigate) => void;
+}
+export interface IClientMiddleware extends IMiddleware<ClientMiddlewareContext, undefined> {
+    execute(context: ClientMiddlewareContext): undefined;
+}
+export type ClientMiddlewareClass = MiddlewareClass<IClientMiddleware>;
+export declare const executeClientMiddlewares: (middlewares: readonly ClientMiddlewareClass[], navigation?: BeforeNavigate) => void;

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

@@ -1,27 +1,48 @@
-import {} from '@sveltejs/kit';
 import { ensureRoute } from './Shared.js';
 import { page } from '$app/state';
 import { goto } from '$app/navigation';
 export const executeClientMiddlewares = (middlewares, navigation) => {
     const from = navigation?.from?.url ?? undefined;
-    const to = navigation?.to?.url ?? page?.url;
+    const to = navigation?.to?.url ?? page.url;
     for (const middleware of middlewares) {
         let shouldContinue = false;
         let redirectTo;
-        const next = (location) => {
+        let redirectOptions;
+        let active = true;
+        const next = (location, options) => {
+            if (!active)
+                throw new Error('[Middleware] next() must be called synchronously and only once.');
+            active = false;
             shouldContinue = true;
             redirectTo = location;
+            redirectOptions = options;
             return undefined;
         };
-        middleware({
-            to,
-            from,
-            next,
-            ensureRoute
-        });
-        if (redirectTo) {
+        let result;
+        try {
+            result = new middleware().execute({
+                to,
+                from,
+                next,
+                ensureRoute,
+                navigation
+            });
+        }
+        catch (error) {
+            navigation?.cancel();
+            throw error;
+        }
+        finally {
+            active = false;
+        }
+        if (result && typeof result.then === 'function') {
+            navigation?.cancel();
+            void Promise.resolve(result).catch(() => undefined);
+            throw new Error('[Middleware] Client execute() must be synchronous.');
+        }
+        if (redirectTo !== undefined) {
             navigation?.cancel();
-            void goto(redirectTo);
+            void goto(redirectTo, redirectOptions).catch((error) => console.error('[Middleware] Redirect failed:', error));
             return;
         }
         if (!shouldContinue) {

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

@@ -1,11 +1,16 @@
 import { type RequestEvent } from '@sveltejs/kit';
 import { type EnsureRoute } from './Shared.js';
-import type { RedirectStatus } from '../../redirect/index.js';
-export type IServerMiddleware = (middlewareData: {
+import type { RedirectStatus } from '../../../svelte/redirect/index.js';
+import type { IMiddleware, MiddlewareClass } from './Types.js';
+export interface ServerMiddlewareContext {
     to: RequestEvent['url'];
     from?: RequestEvent['url'];
     next: (location?: string | URL, status?: RedirectStatus) => void;
-    event?: RequestEvent;
+    event: RequestEvent;
     ensureRoute: EnsureRoute;
-}) => Promise<void> | void;
-export declare const executeServerMiddlewares: (middlewares: IServerMiddleware[]) => Promise<void>;
+}
+export interface IServerMiddleware extends IMiddleware<ServerMiddlewareContext, Promise<void> | void> {
+    execute(context: ServerMiddlewareContext): Promise<void> | void;
+}
+export type ServerMiddlewareClass = MiddlewareClass<IServerMiddleware>;
+export declare const executeServerMiddlewares: (middlewares: readonly ServerMiddlewareClass[]) => Promise<void>;

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

@@ -1,13 +1,13 @@
 import { error, redirect } from '@sveltejs/kit';
 import { ensureRoute } from './Shared.js';
 import { BROWSER } from '../../../external/tools/index.js';
-import { RequestContext } from '../../../external/edges/ServerContext.js';
+import { RequestContext } from '../../../shared/request-context/Internal.js';
 export const executeServerMiddlewares = async (middlewares) => {
     if (!BROWSER && middlewares.length) {
         const event = RequestContext.current().event;
         if (event) {
             const referer = event?.request.headers.get('referer');
-            const from = referer ? new URL(referer) : undefined;
+            const from = referer && URL.canParse(referer) ? new URL(referer) : undefined;
             const to = event?.url;
             for (const middleware of middlewares) {
                 let shouldContinue = false;
@@ -17,7 +17,7 @@ export const executeServerMiddlewares = async (middlewares) => {
                         return redirect(status, location);
                     }
                 };
-                await middleware({
+                await new middleware().execute({
                     event,
                     to,
                     from,

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

@@ -0,0 +1,4 @@
+export interface IMiddleware<TContext, TResult = void> {
+    execute(context: TContext): TResult;
+}
+export type MiddlewareClass<T> = new () => T;

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,4 +1,4 @@
-import { type ContextData } from '../../external/edges/ServerContext.js';
+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 {

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

@@ -1,14 +1,15 @@
+import { getContextInternals } from '../../shared/request-context/Internal.js';
 import { BROWSER } from '../../external/tools/index.js';
-import { RequestContext } from '../../external/edges/ServerContext.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 requestContext.data;
+        return getContextInternals(requestContext);
     try {
-        return RequestContext.current().data;
+        return getContextInternals(RequestContext.current());
     }
     catch {
         return undefined;

package/dist/shared/boundary-provider/CompositionRoot.d.ts

@@ -0,0 +1,21 @@
+import { type ProviderSettings, type ProviderWithType } from './Provider.js';
+type Services = Record<string, () => unknown>;
+type Dependency = ProviderWithType<Services> | {
+    readonly resolve: ProviderWithType<Services>;
+};
+type Dependencies = Record<string, Dependency>;
+type Providers<D extends Dependencies> = {
+    [K in keyof D]: D[K] extends {
+        readonly resolve: infer P extends ProviderWithType<Services>;
+    } ? P : D[K] extends ProviderWithType<Services> ? D[K] : never;
+};
+export type CompositionRootSettings<T extends Services, D extends Dependencies = Record<never, never>> = Omit<ProviderSettings<T, Providers<D>>, 'dependsOn'> & {
+    dependsOn?: D;
+};
+/** Holds registration metadata only. Resolving always uses the current request's container. */
+export declare class CompositionRoot<T extends Services, D extends Dependencies = Record<never, never>> {
+    readonly name: symbol;
+    readonly resolve: ProviderWithType<T>;
+    constructor(settings: CompositionRootSettings<T, D>);
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { CreateServiceContainer } from './Provider.js';
+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');
+    resolve;
+    constructor(settings) {
+        const dependsOn = Object.fromEntries(Object.entries(settings.dependsOn ?? {}).map(([key, dependency]) => [key, toProvider(dependency)]));
+        this.resolve = CreateServiceContainer(this.name, { ...settings, dependsOn });
+    }
+}

package/dist/shared/boundary-provider/Provider.d.ts

@@ -1,3 +1,4 @@
+export type ProviderKey = string | symbol;
 type ServiceFactory<T> = () => T;
 type ServiceMap = Record<string, ServiceFactory<unknown>>;
 type ResolvedServices<T extends ServiceMap> = {
@@ -13,9 +14,9 @@ type ProviderFactory<T extends ServiceMap, D extends Record<string, ProviderWith
 }) => T;
 export interface ProviderSettings<T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>> {
     dependsOn?: D;
-    boot?: (services: ResolvedServices<T>) => void | Promise<void>;
+    boot?: (services: ResolvedServices<T>) => undefined;
     register: ProviderFactory<T, D>;
 }
-export declare const createBoundaryProvider: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: string, settings: ProviderSettings<T, D>) => ProviderWithType<T>;
-export declare function cleanupProvider(name: string): Promise<void>;
+export declare const CreateServiceContainer: <T extends ServiceMap, D extends Record<string, ProviderWithType<ServiceMap>>>(name: ProviderKey, settings: ProviderSettings<T, D>) => ProviderWithType<T>;
+export declare function cleanupProvider(name: ProviderKey): Promise<void>;
 export {};