@azure-net/kit 5.0.4 → 5.1.1

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

@@ -193,7 +193,13 @@ const withTimeout = (signal, timeout) => {
     };
 };
 const shouldRetryError = (error) => {
-    return error instanceof HttpServiceError && error.type === HttpErrorTypes.External;
+    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)
@@ -202,14 +208,16 @@ const normalizeUnknownError = (error) => {
 };
 const parseResponse = async (response, request) => {
     const raw = request.includeRaw && typeof response?.clone === 'function' ? response?.clone() : undefined;
-    let data;
+    const hasNoBody = request.method === HttpInstanceFetchMethods.HEAD || response.status === 204 || response.status === 205;
+    let data = undefined;
     let parseError;
-    try {
-        data = await parseBodyByFormat(response, request.responseFormat);
-    }
-    catch (error) {
-        parseError = normalizeUnknownError(error);
-        data = undefined;
+    if (!hasNoBody) {
+        try {
+            data = await parseBodyByFormat(response, request.responseFormat);
+        }
+        catch (error) {
+            parseError = normalizeUnknownError(error);
+        }
     }
     if (!response.ok || parseError) {
         const message = !response.ok

package/dist/plugin/AzureNetPlugin.d.ts

@@ -1,7 +1,5 @@
 import type { Plugin } from 'vite';
 export interface AzureNetPluginOptions {
     silentChromeDevtools?: boolean;
-    syncFromServer?: boolean;
-    syncTransformMode?: 'ast' | 'regex' | 'hybrid';
 }
 export declare const AzureNetPlugin: (options?: AzureNetPluginOptions) => Plugin;

package/dist/plugin/AzureNetPlugin.js

@@ -1,10 +1,7 @@
 import path from 'node:path';
 import fs from 'node:fs';
-import ts from 'typescript';
 const VIRTUAL_SERVER_UTILS_ID = 'virtual:azure-net-kit/server-utils';
-const VIRTUAL_UNIVERSAL_UTILS_ID = 'virtual:azure-net-kit/universal-utils';
 const RESOLVED_VIRTUAL_SERVER_UTILS_ID = `\0${VIRTUAL_SERVER_UTILS_ID}`;
-const RESOLVED_VIRTUAL_UNIVERSAL_UTILS_ID = `\0${VIRTUAL_UNIVERSAL_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}`;
@@ -12,33 +9,6 @@ const RESOLVED_VIRTUAL_CLIENT_HOOKS_ID = `\0${VIRTUAL_CLIENT_HOOKS_ID}`;
 const VIRTUAL_PROGRAM_ID = 'virtual:azure-net-kit/program';
 const RESOLVED_VIRTUAL_PROGRAM_ID = `\0${VIRTUAL_PROGRAM_ID}`;
 const GENERATED_MARKER = '__AZURE_NET_KIT_VIRTUAL_HOOK__';
-const SYNC_MARKER = "void '__EDGES_SYNC_WRAPPED__';";
-const LOAD_EXPORT_PATTERN = /export\s+const\s+load\s*(?::\s*[^=]+)?=/;
-const ACTIONS_EXPORT_PATTERN = /export\s+const\s+actions\s*(?::\s*[^=]+)?=/;
-const SERVER_ROUTE_PATTERN = /[\\/]\+((page|layout)\.server)\.(t|j)s$/;
-const UNIVERSAL_ROUTE_PATTERN = /[\\/]\+((page|layout))\.(t|j)s$/;
-const AST_SERVER_LOAD_ALIAS = '__edgesWrappedServerLoad';
-const AST_ACTIONS_ALIAS = '__edgesWrappedActions';
-const AST_UNIVERSAL_LOAD_ALIAS = '__edgesWrappedUniversalLoad';
-const applyEdits = (sourceCode, edits) => {
-    if (edits.length === 0)
-        return sourceCode;
-    const sorted = edits.sort((a, b) => b.start - a.start);
-    let result = sourceCode;
-    for (const edit of sorted) {
-        result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
-    }
-    return result;
-};
-const findImportInsertPosition = (sourceCode) => {
-    const importRegex = /(?:^|\n)((?:import|export)\s+(?:type\s+)?(?:\{[^}]*\}|\*|\w+)(?:\s+from)?\s+['"][^'"]+['"];?)/gm;
-    let lastMatch = null;
-    let match;
-    while ((match = importRegex.exec(sourceCode)) !== null) {
-        lastMatch = match;
-    }
-    return lastMatch ? lastMatch.index + lastMatch[0].length : 0;
-};
 const findStaticImportInsertPosition = (sourceCode) => {
     const importRegex = /(?:^|\n)(import\s+(?:type\s+)?(?:\{[^}]*\}|\*|\w+)(?:\s+from)?\s+['"][^'"]+['"];?)/gm;
     let lastMatch = null;
@@ -48,145 +18,15 @@ const findStaticImportInsertPosition = (sourceCode) => {
     }
     return lastMatch ? lastMatch.index + lastMatch[0].length : 0;
 };
-const ensureSyncImport = (sourceCode, importLine) => {
-    if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
-        return sourceCode;
-    const insertPos = findImportInsertPosition(sourceCode);
-    const beforeImports = sourceCode.slice(0, insertPos);
-    const afterImports = sourceCode.slice(insertPos);
-    return `${beforeImports}\n${SYNC_MARKER}\n${importLine}\n${afterImports}`;
-};
-const ensureAstServerImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesServerLoad as ${AST_SERVER_LOAD_ALIAS}, __withEdgesActions as ${AST_ACTIONS_ALIAS} } from '${VIRTUAL_SERVER_UTILS_ID}';`);
-const ensureAstUniversalImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesUniversalLoad as ${AST_UNIVERSAL_LOAD_ALIAS} } from '${VIRTUAL_UNIVERSAL_UTILS_ID}';`);
-const ensureRegexServerImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesServerLoad, __withEdgesActions } from '${VIRTUAL_SERVER_UTILS_ID}';`);
-const ensureRegexUniversalImport = (sourceCode) => ensureSyncImport(sourceCode, `import { __withEdgesUniversalLoad } from '${VIRTUAL_UNIVERSAL_UTILS_ID}';`);
-const findExportedLocal = (sourceFile, code, exportedName) => {
-    const edits = [];
-    let localName = null;
-    let found = false;
-    for (const stmt of sourceFile.statements) {
-        if (ts.isVariableStatement(stmt)) {
-            const exportModifier = stmt.modifiers?.find((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
-            if (!exportModifier)
-                continue;
-            for (const declaration of stmt.declarationList.declarations) {
-                if (!ts.isIdentifier(declaration.name) || declaration.name.text !== exportedName)
-                    continue;
-                localName = declaration.name.text;
-                found = true;
-                const modifierStart = exportModifier.getStart(sourceFile);
-                let modifierEnd = exportModifier.end;
-                while (modifierEnd < code.length && /\s/.test(code[modifierEnd]))
-                    modifierEnd += 1;
-                edits.push({ start: modifierStart, end: modifierEnd, text: '' });
-                break;
-            }
-        }
-        if (!ts.isExportDeclaration(stmt) || !stmt.exportClause || !ts.isNamedExports(stmt.exportClause) || stmt.moduleSpecifier)
-            continue;
-        const keepSpecs = [];
-        let statementHasTarget = false;
-        for (const element of stmt.exportClause.elements) {
-            const exportName = element.name.text;
-            const sourceName = element.propertyName?.text ?? element.name.text;
-            if (exportName === exportedName) {
-                statementHasTarget = true;
-                found = true;
-                localName = sourceName;
-                continue;
-            }
-            keepSpecs.push(code.slice(element.getStart(sourceFile), element.end).trim());
-        }
-        if (!statementHasTarget)
-            continue;
-        if (keepSpecs.length === 0) {
-            edits.push({ start: stmt.getStart(sourceFile), end: stmt.end, text: '' });
-        }
-        else {
-            edits.push({ start: stmt.getStart(sourceFile), end: stmt.end, text: `export { ${keepSpecs.join(', ')} };` });
-        }
-    }
-    return { localName, edits, found };
-};
-const wrapServerRouteModuleRegex = (sourceCode) => {
-    if (!LOAD_EXPORT_PATTERN.test(sourceCode) && !ACTIONS_EXPORT_PATTERN.test(sourceCode))
-        return null;
-    let wrapped = ensureRegexServerImport(sourceCode);
-    if (LOAD_EXPORT_PATTERN.test(wrapped)) {
-        wrapped = wrapped
-            .replace(LOAD_EXPORT_PATTERN, (match) => match.replace('export const load', 'const __userLoad'))
-            .concat('\n\nexport const load = __withEdgesServerLoad(__userLoad);');
-    }
-    if (ACTIONS_EXPORT_PATTERN.test(wrapped)) {
-        wrapped = wrapped
-            .replace(ACTIONS_EXPORT_PATTERN, (match) => match.replace('export const actions', 'const __userActions'))
-            .concat('\n\nexport const actions = __withEdgesActions(__userActions);');
-    }
-    return wrapped;
-};
-const wrapUniversalRouteModuleRegex = (sourceCode) => {
-    if (!LOAD_EXPORT_PATTERN.test(sourceCode))
-        return null;
-    return ensureRegexUniversalImport(sourceCode)
-        .replace(LOAD_EXPORT_PATTERN, (match) => match.replace('export const load', 'const __userUniversalLoad'))
-        .concat('\n\nexport const load = __withEdgesUniversalLoad(__userUniversalLoad);');
-};
-const wrapServerRouteModuleAst = (sourceCode) => {
-    if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
-        return null;
-    let sourceFile;
-    try {
-        sourceFile = ts.createSourceFile('route.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    }
-    catch {
-        return null;
-    }
-    const loadInfo = findExportedLocal(sourceFile, sourceCode, 'load');
-    const actionsInfo = findExportedLocal(sourceFile, sourceCode, 'actions');
-    if (!loadInfo.found && !actionsInfo.found)
-        return null;
-    if ((loadInfo.found && !loadInfo.localName) || (actionsInfo.found && !actionsInfo.localName))
-        return null;
-    let nextCode = applyEdits(sourceCode, [...loadInfo.edits, ...actionsInfo.edits]);
-    nextCode = ensureAstServerImport(nextCode);
-    const append = [];
-    if (loadInfo.localName) {
-        append.push(`const __edgesServerLoad = ${AST_SERVER_LOAD_ALIAS}(${loadInfo.localName});`);
-        append.push('export { __edgesServerLoad as load };');
-    }
-    if (actionsInfo.localName) {
-        append.push(`const __edgesServerActions = ${AST_ACTIONS_ALIAS}(${actionsInfo.localName});`);
-        append.push('export { __edgesServerActions as actions };');
-    }
-    return `${nextCode}\n\n${append.join('\n')}`;
-};
-const wrapUniversalRouteModuleAst = (sourceCode) => {
-    if (sourceCode.includes('__EDGES_SYNC_WRAPPED__'))
-        return null;
-    let sourceFile;
-    try {
-        sourceFile = ts.createSourceFile('route.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    }
-    catch {
-        return null;
-    }
-    const loadInfo = findExportedLocal(sourceFile, sourceCode, 'load');
-    if (!loadInfo.found || !loadInfo.localName)
-        return null;
-    let nextCode = applyEdits(sourceCode, [...loadInfo.edits]);
-    nextCode = ensureAstUniversalImport(nextCode);
-    return `${nextCode}\n\nconst __edgesUniversalLoad = ${AST_UNIVERSAL_LOAD_ALIAS}(${loadInfo.localName});\nexport { __edgesUniversalLoad as load };`;
-};
 const createVirtualServerHooks = (silentChromeDevtools) => `// ${GENERATED_MARKER}
 import { edgesHandle, edgesHandleRaw } from '${VIRTUAL_SERVER_UTILS_ID}';
 
 const getRegister = async () => (await import('${VIRTUAL_PROGRAM_ID}')).register;
 
-export const init = () => undefined;
+export const init = async () => (await getRegister()).serverInit();
 
 export const handle = edgesHandle(async ({ serialize, edgesEvent, resolve }) => {
 	const register = await getRegister();
-	await register.serverInit?.();
 
 	return register.handle({
 		event: edgesEvent,
@@ -203,48 +43,19 @@ export const handle = edgesHandle(async ({ serialize, edgesEvent, resolve }) =>
 ${silentChromeDevtools ? ')' : ', false)'};
 
 export const handleError = async ({ error, event, status, message }) => {
-	const register = await edgesHandleRaw(event, async () => await getRegister());
-
-	return register.serverError({ error, event, status, message });
-};
-`;
-const createVirtualServerUtils = () => "export { edgesHandle, edgesHandleRaw, __autoWrapHandle, __withEdgesServerLoad, __withEdgesActions } from '@azure-net/kit/edges/internal-package/utils';";
-const createVirtualUniversalUtils = () => `const EDGES_STATE_FIELD = '__edges_state__';
-const EDGES_REV_FIELD = '__edges_rev__';
-
-const isObjectRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-
-export const __withEdgesUniversalLoad = (load) => {
-\tconst wrapped = async (...args) => {
-\t\tconst event = args[0];
-\t\tconst result = await load(...args);
-\t\tif (!isObjectRecord(event?.data)) return result;
-
-\t\tconst inheritedState = event.data[EDGES_STATE_FIELD];
-\t\tconst inheritedRev = event.data[EDGES_REV_FIELD];
-\t\tif (!inheritedState) return result;
+	let result;
 
-\t\tif (isObjectRecord(result)) {
-\t\t\treturn {
-\t\t\t\t...result,
-\t\t\t\t[EDGES_STATE_FIELD]: inheritedState,
-\t\t\t\t[EDGES_REV_FIELD]: inheritedRev
-\t\t\t};
-\t\t}
+	await edgesHandleRaw(event, async () => {
+		const register = await getRegister();
+		result = await register.serverError({ error, event, status, message });
 
-\t\tif (result === undefined) {
-\t\t\treturn {
-\t\t\t\t[EDGES_STATE_FIELD]: inheritedState,
-\t\t\t\t[EDGES_REV_FIELD]: inheritedRev
-\t\t\t};
-\t\t}
-
-\t\treturn result;
-\t};
+		return new Response(null, { status: 204 });
+	});
 
-\treturn wrapped;
+	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;
 
@@ -258,10 +69,14 @@ const createVirtualProgram = (root) => {
         return `export { register } from '/src/program.ts';`;
     if (fs.existsSync(jsProgram))
         return `export { register } from '/src/program.js';`;
-    return `import { createApp } from '@azure-net/kit';
-
-export const { register, Container } = createApp((app) => app);
-`;
+    throw new Error('[AzureNetPlugin] src/program.ts is required. Create it and export register from createApp().');
+};
+const assertProgramExists = (root) => {
+    const tsProgram = path.join(root, 'src', 'program.ts');
+    const jsProgram = path.join(root, 'src', 'program.js');
+    if (fs.existsSync(tsProgram) || fs.existsSync(jsProgram))
+        return;
+    throw new Error('[AzureNetPlugin] src/program.ts is required. Create it and export register from createApp().');
 };
 const hasUserHook = (root, hookName) => {
     const srcPath = path.join(root, 'src');
@@ -290,6 +105,13 @@ const ensureVirtualImport = (sourceCode, importLine) => {
 const transformGeneratedServerInternal = (sourceCode) => {
     if (sourceCode.includes(GENERATED_MARKER))
         return null;
+    if (/hooks\.server\.(?:ts|js)/.test(sourceCode)) {
+        throw new Error('[AzureNetPlugin] SvelteKit detected a user-managed hooks.server file. Move its lifecycle code to src/program.ts via createApp().');
+    }
+    const getHooksPattern = /export\s+async\s+function\s+get_hooks\s*\(\)\s*\{[\s\S]*?\n\}/m;
+    if (!getHooksPattern.test(sourceCode)) {
+        throw new Error('[AzureNetPlugin] Unsupported SvelteKit generated server internals: get_hooks() was not found.');
+    }
     const universalImportMatch = sourceCode.match(/\(\{\s*reroute,\s*transport\s*\}\s*=\s*await\s*import\([^)]+\)\);/);
     const universalImport = universalImportMatch?.[0] ? `\n\t${universalImportMatch[0]}` : '';
     const importLine = `import * as __azureNetServerHooks from '${VIRTUAL_SERVER_HOOKS_ID}';`;
@@ -307,15 +129,21 @@ const transformGeneratedServerInternal = (sourceCode) => {
 \t\ttransport
 \t};
 }`;
-    const transformed = ensureVirtualImport(sourceCode, `// ${GENERATED_MARKER}\n${importLine}`).replace(/export\s+async\s+function\s+get_hooks\s*\(\)\s*\{[\s\S]*?\n\}/m, getHooksReplacement);
+    const transformed = ensureVirtualImport(sourceCode, `// ${GENERATED_MARKER}\n${importLine}`).replace(getHooksPattern, getHooksReplacement);
     return transformed;
 };
 const transformGeneratedClientApp = (sourceCode) => {
     if (sourceCode.includes(GENERATED_MARKER))
         return null;
+    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;
+    if (!handleErrorPattern.test(sourceCode)) {
+        throw new Error('[AzureNetPlugin] Unsupported SvelteKit generated client app: default handleError was not found.');
+    }
     let transformed = ensureVirtualImport(sourceCode, `// ${GENERATED_MARKER}\nimport * as __azureNetClientHooks from '${VIRTUAL_CLIENT_HOOKS_ID}';`);
-    transformed = transformed.replace(/import\s+\*\s+as\s+client_hooks\s+from\s+['"][^'"]*hooks\.client\.(?:ts|js)['"];\s*\n*/g, '');
-    transformed = transformed.replace(/handleError:\s*(?:client_hooks\.handleError\s*\|\|\s*)?\(\(\{\s*error\s*\}\)\s*=>\s*\{\s*console\.error\(error\)\s*\}\)/m, 'handleError: __azureNetClientHooks.handleError');
+    transformed = transformed.replace(handleErrorPattern, 'handleError: __azureNetClientHooks.handleError');
     if (/^\s*init:\s*[^,\n]+,?/m.test(transformed)) {
         transformed = transformed.replace(/^\s*init:\s*[^,\n]+,?/m, '\tinit: __azureNetClientHooks.init,');
     }
@@ -325,30 +153,28 @@ const transformGeneratedClientApp = (sourceCode) => {
     return transformed;
 };
 export const AzureNetPlugin = (options) => {
-    const { silentChromeDevtools = true, syncFromServer = true, syncTransformMode = 'hybrid' } = options || {};
+    const { silentChromeDevtools = true } = options ?? {};
     let root = process.cwd();
-    let isTestMode = false;
     return {
         name: 'azure-net-kit-plugin',
         enforce: 'pre',
-        config(config, env) {
+        config(config) {
             root = path.resolve(config.root ?? process.cwd());
-            isTestMode = env.mode === 'test';
             assertNoUserHooks(root);
+            assertProgramExists(root);
         },
         configResolved(config) {
             root = config.root;
-            isTestMode ||= config.mode === 'test';
             assertNoUserHooks(root);
+            assertProgramExists(root);
         },
         buildStart() {
             assertNoUserHooks(root);
+            assertProgramExists(root);
         },
         resolveId(id) {
             if (id === VIRTUAL_SERVER_UTILS_ID)
                 return RESOLVED_VIRTUAL_SERVER_UTILS_ID;
-            if (id === VIRTUAL_UNIVERSAL_UTILS_ID)
-                return RESOLVED_VIRTUAL_UNIVERSAL_UTILS_ID;
             if (id === VIRTUAL_SERVER_HOOKS_ID)
                 return RESOLVED_VIRTUAL_SERVER_HOOKS_ID;
             if (id === VIRTUAL_CLIENT_HOOKS_ID)
@@ -360,8 +186,6 @@ export const AzureNetPlugin = (options) => {
         load(id) {
             if (id === RESOLVED_VIRTUAL_SERVER_UTILS_ID)
                 return createVirtualServerUtils();
-            if (id === RESOLVED_VIRTUAL_UNIVERSAL_UTILS_ID)
-                return createVirtualUniversalUtils();
             if (id === RESOLVED_VIRTUAL_SERVER_HOOKS_ID)
                 return createVirtualServerHooks(silentChromeDevtools);
             if (id === RESOLVED_VIRTUAL_CLIENT_HOOKS_ID)
@@ -371,39 +195,14 @@ export const AzureNetPlugin = (options) => {
             return null;
         },
         transform(code, id) {
-            const normalizedId = id.split(path.sep).join('/');
-            if (!isTestMode && normalizedId.endsWith('/.svelte-kit/generated/server/internal.js')) {
+            const normalizedId = id.split('?')[0].split(path.sep).join('/');
+            if (normalizedId.endsWith('/.svelte-kit/generated/server/internal.js')) {
                 const transformed = transformGeneratedServerInternal(code);
-                if (transformed)
-                    return { code: transformed, map: null };
-                return null;
+                return transformed ? { code: transformed, map: null } : null;
             }
-            if (!isTestMode &&
-                (normalizedId.endsWith('/.svelte-kit/generated/client/app.js') || normalizedId.endsWith('/.svelte-kit/generated/client-optimized/app.js'))) {
+            if (normalizedId.endsWith('/.svelte-kit/generated/client/app.js') || normalizedId.endsWith('/.svelte-kit/generated/client-optimized/app.js')) {
                 const transformed = transformGeneratedClientApp(code);
-                if (transformed)
-                    return { code: transformed, map: null };
-                return null;
-            }
-            if (code.includes('__EDGES_SYNC_WRAPPED__'))
-                return null;
-            if (syncFromServer && SERVER_ROUTE_PATTERN.test(id) && !id.includes('hooks.server')) {
-                const wrapped = syncTransformMode === 'regex'
-                    ? wrapServerRouteModuleRegex(code)
-                    : syncTransformMode === 'ast'
-                        ? wrapServerRouteModuleAst(code)
-                        : (wrapServerRouteModuleAst(code) ?? wrapServerRouteModuleRegex(code));
-                if (wrapped)
-                    return { code: wrapped, map: null };
-            }
-            if (syncFromServer && UNIVERSAL_ROUTE_PATTERN.test(id) && !id.includes('.server.')) {
-                const wrapped = syncTransformMode === 'regex'
-                    ? wrapUniversalRouteModuleRegex(code)
-                    : syncTransformMode === 'ast'
-                        ? wrapUniversalRouteModuleAst(code)
-                        : (wrapUniversalRouteModuleAst(code) ?? wrapUniversalRouteModuleRegex(code));
-                if (wrapped)
-                    return { code: wrapped, map: null };
+                return transformed ? { code: transformed, map: null } : null;
             }
             return null;
         }

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

@@ -38,9 +38,7 @@ export interface AppClientErrorContext<TDependencies extends Record<string, unkn
     status: number;
     message: string;
 }
-export interface AppServerInitLifecycleContext<TDependencies extends Record<string, unknown>> {
-    Container: AppContainer<TDependencies>;
-}
+export type AppServerInitLifecycleContext = void;
 export interface AppServerLifecycleContext<TDependencies extends Record<string, unknown>> {
     Container: AppContainer<TDependencies>;
     requestContext: ContextData;
@@ -61,7 +59,7 @@ export type AppUniversalLifecycleCallback<TDependencies extends Record<string, u
 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 AppServerInitLifecycleCallback<TDependencies extends Record<string, unknown>> = (context: AppServerInitLifecycleContext<TDependencies>) => ReturnType<ServerInit>;
+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 CreateAppBuilder<TDependencies extends Record<string, unknown>, TFlags extends BuilderFlags = object> = {
@@ -76,7 +74,7 @@ export type CreateAppBuilder<TDependencies extends Record<string, unknown>, TFla
 }> & OnceMethod<TFlags, 'useClientError', {
     useClientError(callback: AppClientErrorCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useClientError'>>;
 }> & OnceMethod<TFlags, 'useServerInit', {
-    useServerInit(callback: AppServerInitLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerInit'>>;
+    useServerInit(callback: AppServerInitLifecycleCallback): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServerInit'>>;
 }> & OnceMethod<TFlags, 'useServer', {
     useServer(callback: AppServerLifecycleCallback<TDependencies>): CreateAppBuilder<TDependencies, WithFlag<TFlags, 'useServer'>>;
 }> & OnceMethod<TFlags, 'useServerError', {

package/dist/shared/app/App.js

@@ -8,7 +8,6 @@ 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();
 const getRequestContext = () => {
     try {
         return RequestContext.current();
@@ -17,13 +16,10 @@ const getRequestContext = () => {
         return undefined;
     }
 };
-const getServerRequestContext = (event) => {
+const getServerRequestContext = () => {
     const requestContext = getRequestContext();
     if (requestContext)
         return requestContext;
-    if (event) {
-        return { data: {}, event };
-    }
     throw new AzureNetKitInternalError('[createApp] RequestContext is not initialized on server.');
 };
 const getLifecycleFlags = (appKey, requestContext) => {
@@ -97,6 +93,7 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
     const dependencies = new Map();
     const callbacks = {};
     let clientInitialized = false;
+    let serverInitPromise;
     callback(createBuilder(dependencies, callbacks));
     const AppProvider = createBoundaryProvider(name, {
         register: () => {
@@ -171,22 +168,15 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
     const runServerInit = () => {
         if (BROWSER)
             return undefined;
-        let flags = serverInitLifecycleFlags.get(appKey);
-        if (!flags) {
-            flags = {};
-            serverInitLifecycleFlags.set(appKey, flags);
-        }
-        if (flags.serverInit)
-            return undefined;
-        flags.serverInit = true;
-        return callbacks.useServerInit?.({ Container });
+        serverInitPromise ??= Promise.resolve().then(() => callbacks.useServerInit?.());
+        return serverInitPromise;
     };
     const runServerError = ({ error, event, status, message }) => {
         if (BROWSER)
             return undefined;
         return callbacks.useServerError?.({
             Container,
-            requestContext: getServerRequestContext(event),
+            requestContext: getServerRequestContext(),
             error,
             event,
             status,
@@ -206,7 +196,7 @@ export const createApp = (callback, name = DEFAULT_APP_NAME) => {
         });
     };
     const handle = async ({ event, resolve }) => {
-        const requestContext = getServerRequestContext(event);
+        const requestContext = getServerRequestContext();
         const flags = getLifecycleFlags(appKey, requestContext);
         if (!flags.server) {
             flags.server = true;

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

@@ -7,27 +7,28 @@ export const executeClientMiddlewares = async (middlewares, navigation) => {
     const to = navigation?.to?.url ?? page?.url;
     for (const middleware of middlewares) {
         let shouldContinue = false;
+        let redirectTo;
         const next = (location) => {
             shouldContinue = true;
-            if (location) {
-                if (navigation) {
-                    navigation?.cancel();
-                }
-                return goto(location);
-            }
+            redirectTo = location;
         };
-        await middleware({
+        const result = middleware({
             to,
             from,
             next,
             ensureRoute
         });
+        if (result && typeof result.then === 'function')
+            await result;
+        if (redirectTo) {
+            navigation?.cancel();
+            await goto(redirectTo);
+            return;
+        }
         if (!shouldContinue) {
             navigation?.cancel();
-            if (from) {
-                void goto(from.pathname);
-                console.warn('Navigation blocked: middleware chain stopped (next() not called).');
-            }
+            console.warn('Navigation blocked: middleware chain stopped (next() not called).');
+            return;
         }
     }
 };

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

@@ -2,7 +2,6 @@ import { RequestContext } from '../../external/edges/ServerContext.js';
 import { BROWSER } from '../../external/tools/index.js';
 import { AzureNetKitInternalError } from '../app-error/AppError.js';
 const clientCache = new Map();
-const factoriesCache = new WeakMap();
 const providerProxyCache = new Map();
 const clientConstructionStack = [];
 const clientBootFlags = new Map();
@@ -89,10 +88,6 @@ export const createBoundaryProvider = (name, settings) => {
         const getFactories = () => {
             if (factories)
                 return factories;
-            if (factoriesCache.has(register)) {
-                factories = factoriesCache.get(register);
-                return factories;
-            }
             const deps = {};
             const depInstances = new Map();
             for (const [depName, depProvider] of Object.entries(dependsOn)) {
@@ -107,9 +102,6 @@ export const createBoundaryProvider = (name, settings) => {
                 });
             }
             factories = register(deps);
-            if (BROWSER) {
-                factoriesCache.set(register, factories);
-            }
             return factories;
         };
         const providerProxy = new Proxy({}, {