@azure-net/kit 6.0.0-next.1 → 6.0.0-next.2

package/dist/plugin/AzureNetPlugin.js

@@ -1,7 +1,6 @@
+import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 import fs from 'node:fs';
-const VIRTUAL_SERVER_UTILS_ID = 'virtual:azure-net-kit/server-utils';
-const RESOLVED_VIRTUAL_SERVER_UTILS_ID = `\0${VIRTUAL_SERVER_UTILS_ID}`;
 const VIRTUAL_SERVER_HOOKS_ID = 'virtual:azure-net-kit/hooks.server';
 const VIRTUAL_CLIENT_HOOKS_ID = 'virtual:azure-net-kit/hooks.client';
 const RESOLVED_VIRTUAL_SERVER_HOOKS_ID = `\0${VIRTUAL_SERVER_HOOKS_ID}`;
@@ -18,62 +17,16 @@ const findStaticImportInsertPosition = (sourceCode) => {
     }
     return lastMatch ? lastMatch.index + lastMatch[0].length : 0;
 };
-const createVirtualServerHooks = (silentChromeDevtools) => `// ${GENERATED_MARKER}
-import { edgesHandle, edgesHandleRaw } from '${VIRTUAL_SERVER_UTILS_ID}';
-import { RequestContext } from '@azure-net/kit/server-context';
-
+const createVirtualServerHooks = () => `// ${GENERATED_MARKER}
+import { runRequest } from '@azure-net/kit/internal/server';
 const getRegister = async () => (await import('${VIRTUAL_PROGRAM_ID}')).register;
-
-const withRequestContext = (event, callback) => {
-	try {
-		RequestContext.current();
-	} catch {
-		return edgesHandleRaw(event, callback);
-	}
-
-	return callback();
-};
-
 export const init = async () => (await getRegister()).serverInit();
-export const handleFetch = (input) => withRequestContext(input.event, async () => (await getRegister()).serverFetch(input));
-export const handleValidationError = (input) => withRequestContext(
-	input.event,
-	async () => (await getRegister()).serverValidationError(input)
-);
+export const handle = (input) => runRequest(input.event, async () => (await getRegister()).handle(input));
+export const handleFetch = (input) => runRequest(input.event, async () => (await getRegister()).serverFetch(input));
+export const handleError = (input) => runRequest(input.event, async () => (await getRegister()).serverError(input));
 export const reroute = async (input) => (await getRegister()).reroute(input);
 export const getTransport = async () => (await getRegister()).transport;
-
-export const handle = edgesHandle(async ({ serialize, edgesEvent, resolve }) => {
-	const register = await getRegister();
-
-	return register.handle({
-		event: edgesEvent,
-		resolve: (event, options) =>
-			resolve(event, {
-				...options,
-				transformPageChunk: async (chunk) => {
-					const html = (options?.transformPageChunk ? await options.transformPageChunk(chunk) : undefined) ?? chunk.html;
-					return serialize(html);
-				}
-			})
-	});
-}
-${silentChromeDevtools ? ')' : ', false)'};
-
-export const handleError = async ({ error, event, status, message }) => {
-	let result;
-
-	await edgesHandleRaw(event, async () => {
-		const register = await getRegister();
-		result = await register.serverError({ error, event, status, message });
-
-		return new Response(null, { status: 204 });
-	});
-
-	return result;
-};
 `;
-const createVirtualServerUtils = () => "export { edgesHandle, edgesHandleRaw } from '@azure-net/kit/edges/internal-package/utils';";
 const createVirtualClientHooks = () => `// ${GENERATED_MARKER}
 const getRegister = async () => (await import('${VIRTUAL_PROGRAM_ID}')).register;
 
@@ -155,7 +108,6 @@ const transformGeneratedServerInternal = (sourceCode) => {
 \t\thandle: __azureNetServerHooks.handle,
 \t\thandleFetch: __azureNetServerHooks.handleFetch,
 \t\thandleError: __azureNetServerHooks.handleError,
-\t\thandleValidationError: __azureNetServerHooks.handleValidationError,
 \t\tinit: __azureNetServerHooks.init,
 \t\treroute: __azureNetServerHooks.reroute,
 \t\ttransport: await __azureNetServerHooks.getTransport()
@@ -170,7 +122,7 @@ const transformGeneratedClientApp = (sourceCode) => {
     if (/hooks\.client\.(?:ts|js)/.test(sourceCode)) {
         throw new Error('[AzureNetPlugin] SvelteKit detected a user-managed hooks.client file. Move its lifecycle code to src/program.ts via createApp().');
     }
-    const handleErrorPattern = /handleError:\s*\(\(\{\s*error\s*\}\)\s*=>\s*\{\s*console\.error\(error\)\s*\}\)/m;
+    const handleErrorPattern = /handleError:\s*\(\(\{\s*(?:kind,\s*)?error\s*\}\)\s*=>\s*\{\s*(?:if\s*\(kind === ['"]unknown['"]\)\s*\{\s*)?console\.error\(error\);?\s*\}\s*(?:\}\s*)?\)/m;
     if (!handleErrorPattern.test(sourceCode)) {
         throw new Error('[AzureNetPlugin] Unsupported SvelteKit generated client app: default handleError was not found.');
     }
@@ -193,8 +145,7 @@ const transformGeneratedClientApp = (sourceCode) => {
     transformed = transformed.replace(encodersPattern, 'export const encoders = __azureNetClientHooks.encoders;');
     return transformed;
 };
-export const AzureNetPlugin = (options) => {
-    const { silentChromeDevtools = true } = options ?? {};
+export const AzureNetPlugin = () => {
     let root = process.cwd();
     return {
         name: 'azure-net-kit-plugin',
@@ -214,8 +165,10 @@ export const AzureNetPlugin = (options) => {
             assertProgramExists(root);
         },
         resolveId(id) {
-            if (id === VIRTUAL_SERVER_UTILS_ID)
-                return RESOLVED_VIRTUAL_SERVER_UTILS_ID;
+            if (id === '@azure-net/kit/internal/server') {
+                const runtime = fileURLToPath(new URL('../server/Context/Runtime.js', import.meta.url));
+                return fs.existsSync(runtime) ? runtime : runtime.replace(/\.js$/, '.ts');
+            }
             if (id === VIRTUAL_SERVER_HOOKS_ID)
                 return RESOLVED_VIRTUAL_SERVER_HOOKS_ID;
             if (id === VIRTUAL_CLIENT_HOOKS_ID)
@@ -225,10 +178,8 @@ export const AzureNetPlugin = (options) => {
             return null;
         },
         load(id) {
-            if (id === RESOLVED_VIRTUAL_SERVER_UTILS_ID)
-                return createVirtualServerUtils();
             if (id === RESOLVED_VIRTUAL_SERVER_HOOKS_ID)
-                return createVirtualServerHooks(silentChromeDevtools);
+                return createVirtualServerHooks();
             if (id === RESOLVED_VIRTUAL_CLIENT_HOOKS_ID)
                 return createVirtualClientHooks();
             if (id === RESOLVED_VIRTUAL_PROGRAM_ID)
@@ -237,11 +188,12 @@ export const AzureNetPlugin = (options) => {
         },
         transform(code, id) {
             const normalizedId = id.split('?')[0].split(path.sep).join('/');
-            if (normalizedId.endsWith('/.svelte-kit/generated/server/internal.js')) {
+            if (normalizedId.endsWith('/.svelte-kit/generated/server/internal.js') ||
+                /\/.svelte-kit\/generated\/(?:build|dev)\/server\.js$/.test(normalizedId)) {
                 const transformed = transformGeneratedServerInternal(code);
                 return transformed ? { code: transformed, map: null } : null;
             }
-            if (normalizedId.endsWith('/.svelte-kit/generated/client/app.js') || normalizedId.endsWith('/.svelte-kit/generated/client-optimized/app.js')) {
+            if (/\/.svelte-kit\/generated\/(?:(?:build|dev)\/)?client(?:-optimized)?\/app\.js$/.test(normalizedId)) {
                 const transformed = transformGeneratedClientApp(code);
                 return transformed ? { code: transformed, map: null } : null;
             }

package/dist/plugin/index.d.ts

@@ -1 +1 @@
-export { AzureNetPlugin, type AzureNetPluginOptions } from './AzureNetPlugin.js';
+export { AzureNetPlugin } from './AzureNetPlugin.js';

package/dist/server/Context/Runtime.d.ts

@@ -0,0 +1,2 @@
+import type { RequestEvent } from '@sveltejs/kit';
+export declare function runRequest<T>(event: RequestEvent, callback: () => T): T;

package/dist/server/Context/Runtime.js

@@ -0,0 +1,18 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { initializeRequestContext, getContextInternals } from '../../shared/request-context/Internal.js';
+const storage = new AsyncLocalStorage();
+const contexts = new WeakMap();
+initializeRequestContext(() => storage.getStore());
+export function runRequest(event, callback) {
+    initializeRequestContext(() => storage.getStore());
+    const current = storage.getStore();
+    if (current?.event === event)
+        return callback();
+    let context = contexts.get(event);
+    if (!context) {
+        context = Object.freeze({ event, state: {} });
+        contexts.set(event, context);
+        getContextInternals(context).requestId = Symbol('request');
+    }
+    return storage.run(context, callback);
+}

package/dist/server/Context/index.d.ts

@@ -0,0 +1 @@
+export { RequestContext, type ContextData } from '../../shared/request-context/Internal.js';

package/dist/server/Context/index.js

@@ -0,0 +1 @@
+export { RequestContext } from '../../shared/request-context/Internal.js';

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

@@ -1,74 +1,49 @@
-import { type ContextData } from '../../external/edges/ServerContext.js';
+import { type TranslationManagerFactory } 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 { AppEvents } from '../event-bus/EventBus.js';
 import { type IServerMiddleware } from './middleware/ServerMiddleware.js';
-import type { Handle, HandleClientError, HandleFetch, HandleServerError, HandleValidationError, RequestEvent, Reroute, ServerInit, Transport } from '@sveltejs/kit';
+import type { Handle, HandleFetch, HandleServerError, HandleClientError, Reroute, ServerInit, Transport } from '@sveltejs/kit/hooks';
+import type { RequestEvent } 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'];
-type AppDependencyFactory<TApp, TReturn = unknown> = (app: TApp) => TReturn;
-type AppDependencyFactories<TApp> = Record<string, AppDependencyFactory<TApp>>;
-type ResolvedDependencies<T> = {
-    [K in keyof T]: T[K] extends (...args: never[]) => infer TReturn ? TReturn : never;
-};
-type BuilderFlags = Partial<Record<'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError' | 'useServerFetch' | 'useServerValidationError' | 'useAzureNetKitError' | 'useReroute' | 'useTransport', true>>;
+type BuilderFlags = Partial<Record<'useTranslations' | 'useBoot' | 'use' | 'useClient' | 'useClientInit' | 'useClientError' | 'useServerInit' | 'useServer' | 'useServerError' | 'useServerFetch' | 'useServerValidationError' | 'useAzureNetKitError' | 'useReroute' | 'useTransport', true>>;
 type WithFlag<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags> = TFlags & Record<TKey, true>;
-type BuilderDependencies<TBuilder> = TBuilder extends {
-    readonly __types__?: infer TDependencies;
-} ? TDependencies : never;
 type OnceMethod<TFlags extends BuilderFlags, TKey extends keyof BuilderFlags, TMethod> = TFlags[TKey] extends true ? object : TMethod;
-export type AppContainer<TDependencies extends Record<string, unknown>> = Readonly<TDependencies>;
-export interface AppUniversalLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export interface AppUniversalLifecycleContext {
     isClient: boolean;
     isServer: boolean;
     requestContext?: ContextData;
     event?: RequestEvent;
 }
-export interface AppClientLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export interface AppClientLifecycleContext {
     useMiddlewares: (middlewares: IClientMiddleware[]) => void;
 }
-export interface AppClientInitLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
-}
-export interface AppClientErrorContext<TDependencies extends Record<string, unknown>> extends Omit<AppClientLifecycleContext<TDependencies>, 'useMiddlewares'> {
-    error: unknown;
-    event: Parameters<HandleClientError>[0]['event'];
+export type AppClientInitLifecycleContext = void;
+export type AppClientErrorContext = Parameters<HandleClientError>[0] & {
     status: number;
     message: string;
-}
+};
 export type AppServerInitLifecycleContext = void;
-export interface AppServerLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export interface AppServerLifecycleContext {
     requestContext: ContextData;
     event: RequestEvent;
     resolve: Resolve;
     useMiddlewares: (middlewares: IServerMiddleware[]) => Promise<void>;
 }
-export interface AppServerErrorContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export type AppServerErrorContext = Parameters<HandleServerError>[0] & {
     requestContext: ContextData;
-    error: unknown;
-    event: RequestEvent;
     status: number;
     message: string;
     useLogger: typeof useLogger;
-}
-export type AppServerFetchContext<TDependencies extends Record<string, unknown>> = Parameters<HandleFetch>[0] & {
-    Container: AppContainer<TDependencies>;
-    requestContext: ContextData;
 };
-export type AppServerValidationErrorContext<TDependencies extends Record<string, unknown>> = Parameters<HandleValidationError>[0] & {
-    Container: AppContainer<TDependencies>;
+export type AppServerFetchContext = Parameters<HandleFetch>[0] & {
     requestContext: ContextData;
 };
-export interface AppAzureNetKitErrorContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
-    AppEvents: typeof AppEvents;
+export interface AppAzureNetKitErrorContext {
     error: AppError;
     retry: AsyncHelperRetry;
     isClient: boolean;
@@ -76,44 +51,46 @@ export interface AppAzureNetKitErrorContext<TDependencies extends Record<string,
     requestContext?: ContextData;
     event?: RequestEvent;
 }
-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>;
-export type AppClientInitLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppClientInitLifecycleContext<TDependencies>) => MaybePromise<void>;
-export type AppClientErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppClientErrorContext<TDependencies>) => ReturnType<HandleClientError>;
+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>;
 export type AppServerInitLifecycleCallback = ServerInit;
-export type AppServerLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppServerLifecycleContext<TDependencies>) => MaybePromise<Response | void>;
-export type AppServerErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppServerErrorContext<TDependencies>) => ReturnType<HandleServerError>;
-export type AppServerFetchCallback<TDependencies extends Record<string, unknown>> = (context: AppServerFetchContext<TDependencies>) => ReturnType<HandleFetch>;
-export type AppServerValidationErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppServerValidationErrorContext<TDependencies>) => ReturnType<HandleValidationError>;
-export type AppAzureNetKitErrorCallback<TDependencies extends Record<string, unknown>> = (context: AppAzureNetKitErrorContext<TDependencies>) => MaybePromise<IAppError & object>;
+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 type CreateAppBuilder<TDependencies extends Record<string, unknown>, TFlags extends BuilderFlags = object> = {
-    readonly __types__?: TDependencies;
-    dependencies<TNext extends AppDependencyFactories<AppContainer<TDependencies>>>(dependencies: TNext): CreateAppBuilder<TDependencies & ResolvedDependencies<TNext>, TFlags>;
-} & OnceMethod<TFlags, 'use', {
-    use(callback: AppUniversalLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'use'>>;
+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: TranslationManagerFactory): CreateAppBuilder<WithFlag<TFlags, 'useTranslations'>>;
+}> & OnceMethod<TFlags, 'use', {
+    use(callback: AppUniversalLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'use'>>;
 }> & OnceMethod<TFlags, 'useClient', {
-    useClient(callback: AppClientLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClient'>>;
+    useClient(callback: AppClientLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useClient'>>;
 }> & OnceMethod<TFlags, 'useClientInit', {
-    useClientInit(callback: AppClientInitLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClientInit'>>;
+    useClientInit(callback: AppClientInitLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useClientInit'>>;
 }> & OnceMethod<TFlags, 'useClientError', {
-    useClientError(callback: AppClientErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClientError'>>;
+    useClientError(callback: AppClientErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useClientError'>>;
 }> & OnceMethod<TFlags, 'useServerInit', {
-    useServerInit(callback: AppServerInitLifecycleCallback): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerInit'>>;
+    useServerInit(callback: AppServerInitLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerInit'>>;
 }> & OnceMethod<TFlags, 'useServer', {
-    useServer(callback: AppServerLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServer'>>;
+    useServer(callback: AppServerLifecycleCallback): CreateAppBuilder<WithFlag<TFlags, 'useServer'>>;
 }> & OnceMethod<TFlags, 'useServerError', {
-    useServerError(callback: AppServerErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerError'>>;
+    useServerError(callback: AppServerErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerError'>>;
 }> & OnceMethod<TFlags, 'useServerFetch', {
-    useServerFetch(callback: AppServerFetchCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerFetch'>>;
-}> & OnceMethod<TFlags, 'useServerValidationError', {
-    useServerValidationError(callback: AppServerValidationErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerValidationError'>>;
+    useServerFetch(callback: AppServerFetchCallback): CreateAppBuilder<WithFlag<TFlags, 'useServerFetch'>>;
 }> & OnceMethod<TFlags, 'useAzureNetKitError', {
-    useAzureNetKitError(callback: AppAzureNetKitErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useAzureNetKitError'>>;
+    useAzureNetKitError(callback: AppAzureNetKitErrorCallback): CreateAppBuilder<WithFlag<TFlags, 'useAzureNetKitError'>>;
 }> & OnceMethod<TFlags, 'useReroute', {
-    useReroute(callback: AppRerouteCallback): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useReroute'>>;
+    useReroute(callback: AppRerouteCallback): CreateAppBuilder<WithFlag<TFlags, 'useReroute'>>;
 }> & OnceMethod<TFlags, 'useTransport', {
-    useTransport(transport: Transport): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useTransport'>>;
+    useTransport(transport: Transport): CreateAppBuilder<WithFlag<TFlags, 'useTransport'>>;
 }>;
 export interface AppRegistrar {
     (): MaybePromise<void>;
@@ -122,14 +99,12 @@ export interface AppRegistrar {
     serverInit: ServerInit;
     serverError: HandleServerError;
     serverFetch: HandleFetch;
-    serverValidationError: HandleValidationError;
     handle: Handle;
     reroute: Reroute;
     transport: Transport;
 }
-export interface CreateAppInstance<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
+export interface CreateAppInstance {
     register: AppRegistrar;
 }
-export declare const createApp: <TBuilder>(callback: (app: CreateAppBuilder<Record<string, never>>) => TBuilder, name?: string) => CreateAppInstance<BuilderDependencies<TBuilder> & Record<string, unknown>>;
+export declare const createApp: (callback: (app: CreateAppBuilder) => unknown) => CreateAppInstance;
 export {};